Adding analyzer project

Contains two analyzers with fixes

* Use AnsiConsole over System.Console
* Favor local instance over static implementation

src/Spectre.Console.Analyzer/Analyzers/BaseAnalyzer.cs

@@ -0,0 +1,25 @@
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace Spectre.Console.Analyzer
+{
+    /// <summary>
+    /// Base class for Spectre analyzers.
+    /// </summary>
+    public abstract class BaseAnalyzer : DiagnosticAnalyzer
+    {
+        /// <inheritdoc />
+        public override void Initialize(AnalysisContext context)
+        {
+            context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.Analyze | GeneratedCodeAnalysisFlags.ReportDiagnostics);
+            context.EnableConcurrentExecution();
+
+            context.RegisterCompilationStartAction(AnalyzeCompilation);
+        }
+
+        /// <summary>
+        /// Analyze compilation.
+        /// </summary>
+        /// <param name="compilationStartContext">Compilation Start Analysis Context.</param>
+        protected abstract void AnalyzeCompilation(CompilationStartAnalysisContext compilationStartContext);
+    }
+}

src/Spectre.Console.Analyzer/Analyzers/FavorInstanceAnsiConsoleOverStaticAnalyzer.cs

@@ -0,0 +1,89 @@
+using System.Collections.Immutable;
+using System.Linq;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Operations;
+
+namespace Spectre.Console.Analyzer
+{
+    /// <summary>
+    /// Analyzer to suggest using available instances of AnsiConsole over the static methods.
+    /// </summary>
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public class FavorInstanceAnsiConsoleOverStaticAnalyzer : BaseAnalyzer
+    {
+        private static readonly DiagnosticDescriptor _diagnosticDescriptor =
+            Descriptors.S1010_FavorInstanceAnsiConsoleOverStatic;
+
+        /// <inheritdoc />
+        public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics =>
+            ImmutableArray.Create(_diagnosticDescriptor);
+
+        /// <inheritdoc />
+        protected override void AnalyzeCompilation(CompilationStartAnalysisContext compilationStartContext)
+        {
+            compilationStartContext.RegisterOperationAction(
+                context =>
+                {
+                    var ansiConsoleType = context.Compilation.GetTypeByMetadataName("Spectre.Console.AnsiConsole");
+
+                    // if this operation isn't an invocation against one of the System.Console methods
+                    // defined in _methods then we can safely stop analyzing and return;
+                    var invocationOperation = (IInvocationOperation)context.Operation;
+                    if (!Equals(invocationOperation.TargetMethod.ContainingType, ansiConsoleType))
+                    {
+                        return;
+                    }
+
+                    if (!HasFieldAnsiConsole(invocationOperation.Syntax) &&
+                        !HasParameterAnsiConsole(invocationOperation.Syntax))
+                    {
+                        return;
+                    }
+
+                    var methodSymbol = invocationOperation.TargetMethod;
+
+                    var displayString = SymbolDisplay.ToDisplayString(
+                        methodSymbol,
+                        SymbolDisplayFormat.CSharpShortErrorMessageFormat
+                            .WithParameterOptions(SymbolDisplayParameterOptions.None)
+                            .WithGenericsOptions(SymbolDisplayGenericsOptions.None));
+
+                    context.ReportDiagnostic(
+                        Diagnostic.Create(
+                            _diagnosticDescriptor,
+                            invocationOperation.Syntax.GetLocation(),
+                            displayString));
+                }, OperationKind.Invocation);
+        }
+
+        private static bool HasParameterAnsiConsole(SyntaxNode syntaxNode)
+        {
+            return syntaxNode
+                .Ancestors().OfType<MethodDeclarationSyntax>()
+                .First()
+                .ParameterList.Parameters
+                .Any(i => i.Type.NormalizeWhitespace().ToString() == "IAnsiConsole");
+        }
+
+        private static bool HasFieldAnsiConsole(SyntaxNode syntaxNode)
+        {
+            var isStatic = syntaxNode
+                .Ancestors()
+                .OfType<MethodDeclarationSyntax>()
+                .First()
+                .Modifiers.Any(i => i.Kind() == SyntaxKind.StaticKeyword);
+
+            return syntaxNode
+                .Ancestors().OfType<ClassDeclarationSyntax>()
+                .First()
+                .Members
+                .OfType<FieldDeclarationSyntax>()
+                .Any(i =>
+                    i.Declaration.Type.NormalizeWhitespace().ToString() == "IAnsiConsole" &&
+                    (!isStatic ^ i.Modifiers.Any(modifier => modifier.Kind() == SyntaxKind.StaticKeyword)));
+        }
+    }
+}

src/Spectre.Console.Analyzer/Analyzers/UseSpectreInsteadOfSystemConsoleAnalyzer.cs

@@ -0,0 +1,63 @@
+using System.Collections.Immutable;
+using System.Linq;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Operations;
+
+namespace Spectre.Console.Analyzer
+{
+    /// <summary>
+    /// Analyzer to enforce the use of AnsiConsole over System.Console for known methods.
+    /// </summary>
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public class UseSpectreInsteadOfSystemConsoleAnalyzer : BaseAnalyzer
+    {
+        private static readonly DiagnosticDescriptor _diagnosticDescriptor =
+            Descriptors.S1000_UseAnsiConsoleOverSystemConsole;
+
+        private static readonly string[] _methods = { "WriteLine", "Write" };
+
+        /// <inheritdoc />
+        public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics =>
+            ImmutableArray.Create(_diagnosticDescriptor);
+
+        /// <inheritdoc />
+        protected override void AnalyzeCompilation(CompilationStartAnalysisContext compilationStartContext)
+        {
+            compilationStartContext.RegisterOperationAction(
+                context =>
+            {
+                // if this operation isn't an invocation against one of the System.Console methods
+                // defined in _methods then we can safely stop analyzing and return;
+                var invocationOperation = (IInvocationOperation)context.Operation;
+                var systemConsoleType = context.Compilation.GetTypeByMetadataName("System.Console");
+
+                if (!Equals(invocationOperation.TargetMethod.ContainingType, systemConsoleType))
+                {
+                    return;
+                }
+
+                var methodName = System.Array.Find(_methods, i => i.Equals(invocationOperation.TargetMethod.Name));
+                if (methodName == null)
+                {
+                    return;
+                }
+
+                var methodSymbol = invocationOperation.TargetMethod;
+
+                var displayString = SymbolDisplay.ToDisplayString(
+                    methodSymbol,
+                    SymbolDisplayFormat.CSharpShortErrorMessageFormat
+                        .WithParameterOptions(SymbolDisplayParameterOptions.None)
+                        .WithGenericsOptions(SymbolDisplayGenericsOptions.None));
+
+                context.ReportDiagnostic(
+                    Diagnostic.Create(
+                        _diagnosticDescriptor,
+                        invocationOperation.Syntax.GetLocation(),
+                        displayString));
+            }, OperationKind.Invocation);
+        }
+    }
+}

src/Spectre.Console.Analyzer/Constants.cs

@@ -0,0 +1,8 @@
+namespace Spectre.Console.Analyzer
+{
+    internal static class Constants
+    {
+        internal const string StaticInstance = "AnsiConsole";
+        internal const string SpectreConsole = "Spectre.Console";
+    }
+}

src/Spectre.Console.Analyzer/Descriptors.cs

@@ -0,0 +1,49 @@
+using System.Collections.Concurrent;
+using Microsoft.CodeAnalysis;
+using static Microsoft.CodeAnalysis.DiagnosticSeverity;
+using static Spectre.Console.Analyzer.Descriptors.Category;
+
+namespace Spectre.Console.Analyzer
+{
+    /// <summary>
+    /// Code analysis descriptors.
+    /// </summary>
+    public static class Descriptors
+    {
+        internal enum Category
+        {
+            Usage, // 1xxx
+        }
+
+        private static readonly ConcurrentDictionary<Category, string> _categoryMapping = new();
+
+        private static DiagnosticDescriptor Rule(string id, string title, Category category, DiagnosticSeverity defaultSeverity, string messageFormat, string? description = null)
+        {
+            var helpLink = $"https://spectreconsole.net/spectre.console.analyzers/rules/{id}";
+            const bool IsEnabledByDefault = true;
+            return new DiagnosticDescriptor(id, title, messageFormat, _categoryMapping.GetOrAdd(category, c => c.ToString()), defaultSeverity, IsEnabledByDefault, description, helpLink);
+        }
+
+        /// <summary>
+        /// Gets definitions of diagnostics Spectre1000.
+        /// </summary>
+        public static DiagnosticDescriptor S1000_UseAnsiConsoleOverSystemConsole { get; } =
+            Rule(
+                "Spectre1000",
+                "Use AnsiConsole instead of System.Console",
+                Usage,
+                Warning,
+                "Use AnsiConsole instead of System.Console");
+
+        /// <summary>
+        /// Gets definitions of diagnostics Spectre1010.
+        /// </summary>
+        public static DiagnosticDescriptor S1010_FavorInstanceAnsiConsoleOverStatic { get; } =
+            Rule(
+                "Spectre1010",
+                "Favor the use of the instance of AnsiConsole over the static helper.",
+                Usage,
+                Info,
+                "Favor the use of the instance of AnsiConsole over the static helper.");
+    }
+}

src/Spectre.Console.Analyzer/Fixes/CodeActions/SwitchToAnsiConsoleAction.cs

@@ -0,0 +1,115 @@
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
+
+namespace Spectre.Console.Analyzer.CodeActions
+{
+    /// <summary>
+    /// Code action to change calls to System.Console to AnsiConsole.
+    /// </summary>
+    public class SwitchToAnsiConsoleAction : CodeAction
+    {
+        private readonly Document _document;
+        private readonly InvocationExpressionSyntax _originalInvocation;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SwitchToAnsiConsoleAction"/> class.
+        /// </summary>
+        /// <param name="document">Document to change.</param>
+        /// <param name="originalInvocation">The method to change.</param>
+        /// <param name="title">Title of the fix.</param>
+        public SwitchToAnsiConsoleAction(Document document, InvocationExpressionSyntax originalInvocation, string title)
+        {
+            _document = document;
+            _originalInvocation = originalInvocation;
+            Title = title;
+        }
+
+        /// <inheritdoc />
+        public override string Title { get; }
+
+        /// <inheritdoc />
+        public override string EquivalenceKey => Title;
+
+        /// <inheritdoc />
+        protected override async Task<Document> GetChangedDocumentAsync(CancellationToken cancellationToken)
+        {
+            var originalCaller = ((MemberAccessExpressionSyntax)_originalInvocation.Expression).Name.ToString();
+
+            var syntaxTree = await _document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
+            var root = (CompilationUnitSyntax)await syntaxTree.GetRootAsync(cancellationToken).ConfigureAwait(false);
+
+            // If there is an ansiConsole passed into the method then we'll use it.
+            // otherwise we'll check for a field level instance.
+            // if neither of those exist we'll fall back to the static param.
+            var ansiConsoleParameterDeclaration = GetAnsiConsoleParameterDeclaration();
+            var ansiConsoleFieldIdentifier = GetAnsiConsoleFieldDeclaration();
+            var ansiConsoleIdentifier = ansiConsoleParameterDeclaration ??
+                                        ansiConsoleFieldIdentifier ??
+                                        Constants.StaticInstance;
+
+            // Replace the System.Console call with a call to the identifier above.
+            var newRoot = root.ReplaceNode(
+                _originalInvocation,
+                GetImportedSpectreCall(originalCaller, ansiConsoleIdentifier));
+
+            // If we are calling the static instance and Spectre isn't imported yet we should do so.
+            if (ansiConsoleIdentifier == Constants.StaticInstance && root.Usings.ToList().All(i => i.Name.ToString() != Constants.SpectreConsole))
+            {
+                newRoot = newRoot.AddUsings(Syntax.SpectreUsing);
+            }
+
+            return _document.WithSyntaxRoot(newRoot);
+        }
+
+        private string? GetAnsiConsoleParameterDeclaration()
+        {
+            return _originalInvocation
+                .Ancestors().OfType<MethodDeclarationSyntax>()
+                .First()
+                .ParameterList.Parameters
+                .FirstOrDefault(i => i.Type.NormalizeWhitespace().ToString() == "IAnsiConsole")
+                ?.Identifier.Text;
+        }
+
+        private string? GetAnsiConsoleFieldDeclaration()
+        {
+            // let's look to see if our call is in a static method.
+            // if so we'll only want to look for static IAnsiConsoles
+            // and vice-versa if we aren't.
+            var isStatic = _originalInvocation
+                .Ancestors()
+                .OfType<MethodDeclarationSyntax>()
+                .First()
+                .Modifiers.Any(i => i.Kind() == SyntaxKind.StaticKeyword);
+
+            return _originalInvocation
+                .Ancestors().OfType<ClassDeclarationSyntax>()
+                .First()
+                .Members
+                .OfType<FieldDeclarationSyntax>()
+                .FirstOrDefault(i =>
+                    i.Declaration.Type.NormalizeWhitespace().ToString() == "IAnsiConsole" &&
+                    (!isStatic ^ i.Modifiers.Any(modifier => modifier.Kind() == SyntaxKind.StaticKeyword)))
+                ?.Declaration.Variables.First().Identifier.Text;
+        }
+
+        private ExpressionSyntax GetImportedSpectreCall(string originalCaller, string ansiConsoleIdentifier)
+        {
+            return ExpressionStatement(
+                    InvocationExpression(
+                            MemberAccessExpression(
+                                SyntaxKind.SimpleMemberAccessExpression,
+                                IdentifierName(ansiConsoleIdentifier),
+                                IdentifierName(originalCaller)))
+                        .WithArgumentList(
+                        _originalInvocation.ArgumentList))
+            .Expression;
+        }
+    }
+}

src/Spectre.Console.Analyzer/Fixes/FixProviders/StaticAnsiConsoleToInstanceFix.cs

@@ -0,0 +1,35 @@
+using System.Collections.Immutable;
+using System.Composition;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Spectre.Console.Analyzer.CodeActions;
+
+namespace Spectre.Console.Analyzer.FixProviders
+{
+    /// <summary>
+    /// Fix provider to change System.Console calls to AnsiConsole calls.
+    /// </summary>
+    [ExportCodeFixProvider(LanguageNames.CSharp)]
+    [Shared]
+    public class StaticAnsiConsoleToInstanceFix : CodeFixProvider
+    {
+        /// <inheritdoc />
+        public sealed override ImmutableArray<string> FixableDiagnosticIds => ImmutableArray.Create(
+            Descriptors.S1010_FavorInstanceAnsiConsoleOverStatic.Id);
+
+        /// <inheritdoc />
+        public sealed override FixAllProvider GetFixAllProvider() => WellKnownFixAllProviders.BatchFixer;
+
+        /// <inheritdoc />
+        public override async Task RegisterCodeFixesAsync(CodeFixContext context)
+        {
+            var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
+            var methodDeclaration = root.FindNode(context.Span).FirstAncestorOrSelf<InvocationExpressionSyntax>();
+            context.RegisterCodeFix(
+                new SwitchToAnsiConsoleAction(context.Document, methodDeclaration, "Convert static AnsiConsole calls to local instance."),
+                context.Diagnostics);
+        }
+    }
+}

src/Spectre.Console.Analyzer/Fixes/FixProviders/SystemConsoleToAnsiConsoleFix.cs

@@ -0,0 +1,35 @@
+using System.Collections.Immutable;
+using System.Composition;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Spectre.Console.Analyzer.CodeActions;
+
+namespace Spectre.Console.Analyzer.FixProviders
+{
+    /// <summary>
+    /// Fix provider to change System.Console calls to AnsiConsole calls.
+    /// </summary>
+    [ExportCodeFixProvider(LanguageNames.CSharp)]
+    [Shared]
+    public class SystemConsoleToAnsiConsoleFix : CodeFixProvider
+    {
+        /// <inheritdoc />
+        public sealed override ImmutableArray<string> FixableDiagnosticIds => ImmutableArray.Create(
+            Descriptors.S1000_UseAnsiConsoleOverSystemConsole.Id);
+
+        /// <inheritdoc />
+        public sealed override FixAllProvider GetFixAllProvider() => WellKnownFixAllProviders.BatchFixer;
+
+        /// <inheritdoc />
+        public override async Task RegisterCodeFixesAsync(CodeFixContext context)
+        {
+            var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
+            var methodDeclaration = root.FindNode(context.Span).FirstAncestorOrSelf<InvocationExpressionSyntax>();
+            context.RegisterCodeFix(
+                new SwitchToAnsiConsoleAction(context.Document, methodDeclaration, "Convert static call to AnsiConsole to Spectre.Console.AnsiConsole"),
+                context.Diagnostics);
+        }
+    }
+}

src/Spectre.Console.Analyzer/Fixes/Syntax.cs

@@ -0,0 +1,10 @@
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
+
+namespace Spectre.Console.Analyzer
+{
+    internal static class Syntax
+    {
+        public static readonly UsingDirectiveSyntax SpectreUsing = UsingDirective(QualifiedName(IdentifierName("Spectre"), IdentifierName("Console")));
+    }
+}

src/Spectre.Console.Analyzer/Spectre.Console.Analyzer.csproj

@@ -0,0 +1,23 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>netstandard2.0</TargetFramework>
+        <IsPackable>true</IsPackable>
+        <Nullable>enable</Nullable>
+    </PropertyGroup>
+    <ItemGroup>
+        <AdditionalFiles Include="..\stylecop.json" Link="Properties/stylecop.json" />
+        <None Include="../../resources/gfx/small-logo.png" Pack="true" PackagePath="\" Link="Properties/small-logo.png" />
+    </ItemGroup>
+    
+    <ItemGroup>
+        <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="2.9.8" PrivateAssets="all" />
+        <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="2.6.1" />
+        <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="2.6.1" />
+    </ItemGroup>
+
+    <ItemGroup>
+        <None Update="tools\*.ps1" CopyToOutputDirectory="Always" Pack="true" PackagePath="tools" />
+        <None Include="$(OutputPath)\$(AssemblyName).dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
+    </ItemGroup>
+</Project>