Update version

Not happy with how it looks right now. Confusing to the user.

.gitattributes

@@ -1,63 +0,0 @@
-###############################################################################
-# Set default behavior to automatically normalize line endings.
-###############################################################################
-* text=auto
-
-###############################################################################
-# Set default behavior for command prompt diff.
-#
-# This is need for earlier builds of msysgit that does not have it on by
-# default for csharp files.
-# Note: This is only used by command line
-###############################################################################
-#*.cs     diff=csharp
-
-###############################################################################
-# Set the merge driver for project and solution files
-#
-# Merging from the command prompt will add diff markers to the files if there
-# are conflicts (Merging from VS is not affected by the settings below, in VS
-# the diff markers are never inserted). Diff markers may cause the following 
-# file extensions to fail to load in VS. An alternative would be to treat
-# these files as binary and thus will always conflict and require user
-# intervention with every merge. To do so, just uncomment the entries below
-###############################################################################
-#*.sln       merge=binary
-#*.csproj    merge=binary
-#*.vbproj    merge=binary
-#*.vcxproj   merge=binary
-#*.vcproj    merge=binary
-#*.dbproj    merge=binary
-#*.fsproj    merge=binary
-#*.lsproj    merge=binary
-#*.wixproj   merge=binary
-#*.modelproj merge=binary
-#*.sqlproj   merge=binary
-#*.wwaproj   merge=binary
-
-###############################################################################
-# behavior for image files
-#
-# image files are treated as binary by default.
-###############################################################################
-#*.jpg   binary
-#*.png   binary
-#*.gif   binary
-
-###############################################################################
-# diff behavior for common document formats
-# 
-# Convert binary document formats to text before diffing them. This feature
-# is only available from the command line. Turn it on by uncommenting the 
-# entries below.
-###############################################################################
-#*.doc   diff=astextplain
-#*.DOC   diff=astextplain
-#*.docx  diff=astextplain
-#*.DOCX  diff=astextplain
-#*.dot   diff=astextplain
-#*.DOT   diff=astextplain
-#*.pdf   diff=astextplain
-#*.PDF   diff=astextplain
-#*.rtf   diff=astextplain
-#*.RTF   diff=astextplain

.github/workflows/CD.yml

@@ -3,7 +3,7 @@ name: CD
 on:
   push:
     tags:
-    - '*'
+      - "*"
 
 jobs:
   build:
@@ -11,15 +11,17 @@ jobs:
 
     steps:
       - name: Checkout
-      uses: actions/checkout@v1
+        uses: actions/checkout@v2.3.3
 
-    - name: Install .NET Core
-      uses: actions/setup-dotnet@v1
+      - name: Install .NET
+        uses: actions/setup-dotnet@v1.7.2
         with:
-        dotnet-version: 3.1.100
+          dotnet-version: 5.0.x
 
       - name: Pack
-      run: dotnet pack CliFx --configuration Release
+        run: |
+          dotnet nuget locals all --clear
+          dotnet pack CliFx --configuration Release
 
       - name: Deploy
-      run: dotnet nuget push CliFx/bin/Release/*.nupkg -s nuget.org -k ${{secrets.NUGET_TOKEN}}
+        run: dotnet nuget push CliFx/bin/Release/*.nupkg -s nuget.org -k ${{ secrets.NUGET_TOKEN }}

.github/workflows/CI.yml

@@ -4,19 +4,27 @@ on: [push, pull_request]
 
 jobs:
   build:
-    runs-on: ubuntu-latest
+    runs-on: ${{ matrix.os }}
+
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
 
     steps:
       - name: Checkout
-      uses: actions/checkout@v1
+        uses: actions/checkout@v2.3.3
 
-    - name: Install .NET Core
-      uses: actions/setup-dotnet@v1
+      - name: Install .NET
+        uses: actions/setup-dotnet@v1.7.2
         with:
-        dotnet-version: 3.1.100
+          dotnet-version: 5.0.x
 
       - name: Build & test
-      run: dotnet test --configuration Release
+        run: |
+          dotnet nuget locals all --clear
+          dotnet test --configuration Release --logger GitHubActions
 
-    - name: Coverage
-      run: curl -s https://codecov.io/bash | bash -s -- -f CliFx.Tests/bin/Release/Coverage.xml -t ${{secrets.CODECOV_TOKEN}} -Z
+      - name: Upload coverage
+        uses: codecov/codecov-action@v1.0.5
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}

.gitignore

@@ -1,341 +1,21 @@
-## Ignore Visual Studio temporary files, build results, and
-## files generated by popular Visual Studio add-ons.
-##
-## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore
-
 # User-specific files
-*.rsuser
 *.suo
 *.user
 *.userosscache
 *.sln.docstates
-
-# User-specific files (MonoDevelop/Xamarin Studio)
-*.userprefs
+.idea/
 
 # Build results
 [Dd]ebug/
 [Dd]ebugPublic/
 [Rr]elease/
 [Rr]eleases/
-x64/
-x86/
-[Aa][Rr][Mm]/
-[Aa][Rr][Mm]64/
+[Xx]64/
+[Xx]86/
+[Bb]uild/
 bld/
 [Bb]in/
 [Oo]bj/
-[Ll]og/
 
-# Visual Studio 2015/2017 cache/options directory
-.vs/
-# Uncomment if you have tasks that create the project's static files in wwwroot
-#wwwroot/
-
-# Visual Studio 2017 auto generated files
-Generated\ Files/
-
-# MSTest test Results
-[Tt]est[Rr]esult*/
-[Bb]uild[Ll]og.*
-
-# NUNIT
-*.VisualState.xml
-TestResult.xml
-
-# Build Results of an ATL Project
-[Dd]ebugPS/
-[Rr]eleasePS/
-dlldata.c
-
-# Benchmark Results
-BenchmarkDotNet.Artifacts/
-
-# .NET Core
-project.lock.json
-project.fragment.lock.json
-artifacts/
-
-# StyleCop
-StyleCopReport.xml
-
-# Files built by Visual Studio
-*_i.c
-*_p.c
-*_h.h
-*.ilk
-*.meta
-*.obj
-*.iobj
-*.pch
-*.pdb
-*.ipdb
-*.pgc
-*.pgd
-*.rsp
-*.sbr
-*.tlb
-*.tli
-*.tlh
-*.tmp
-*.tmp_proj
-*_wpftmp.csproj
-*.log
-*.vspscc
-*.vssscc
-.builds
-*.pidb
-*.svclog
-*.scc
-
-# Chutzpah Test files
-_Chutzpah*
-
-# Visual C++ cache files
-ipch/
-*.aps
-*.ncb
-*.opendb
-*.opensdf
-*.sdf
-*.cachefile
-*.VC.db
-*.VC.VC.opendb
-
-# Visual Studio profiler
-*.psess
-*.vsp
-*.vspx
-*.sap
-
-# Visual Studio Trace Files
-*.e2e
-
-# TFS 2012 Local Workspace
-$tf/
-
-# Guidance Automation Toolkit
-*.gpState
-
-# ReSharper is a .NET coding add-in
-_ReSharper*/
-*.[Rr]e[Ss]harper
-*.DotSettings.user
-
-# JustCode is a .NET coding add-in
-.JustCode
-
-# TeamCity is a build add-in
-_TeamCity*
-
-# DotCover is a Code Coverage Tool
-*.dotCover
-
-# AxoCover is a Code Coverage Tool
-.axoCover/*
-!.axoCover/settings.json
-
-# Visual Studio code coverage results
-*.coverage
-*.coveragexml
-
-# NCrunch
-_NCrunch_*
-.*crunch*.local.xml
-nCrunchTemp_*
-.ncrunchsolution
-
-# MightyMoose
-*.mm.*
-AutoTest.Net/
-
-# Web workbench (sass)
-.sass-cache/
-
-# Installshield output folder
-[Ee]xpress/
-
-# DocProject is a documentation generator add-in
-DocProject/buildhelp/
-DocProject/Help/*.HxT
-DocProject/Help/*.HxC
-DocProject/Help/*.hhc
-DocProject/Help/*.hhk
-DocProject/Help/*.hhp
-DocProject/Help/Html2
-DocProject/Help/html
-
-# Click-Once directory
-publish/
-
-# Publish Web Output
-*.[Pp]ublish.xml
-*.azurePubxml
-# Note: Comment the next line if you want to checkin your web deploy settings,
-# but database connection strings (with potential passwords) will be unencrypted
-*.pubxml
-*.publishproj
-
-# Microsoft Azure Web App publish settings. Comment the next line if you want to
-# checkin your Azure Web App publish settings, but sensitive information contained
-# in these scripts will be unencrypted
-PublishScripts/
-
-# NuGet Packages
-*.nupkg
-# The packages folder can be ignored because of Package Restore
-**/[Pp]ackages/*
-# except build/, which is used as an MSBuild target.
-!**/[Pp]ackages/build/
-# Uncomment if necessary however generally it will be regenerated when needed
-#!**/[Pp]ackages/repositories.config
-# NuGet v3's project.json files produces more ignorable files
-*.nuget.props
-*.nuget.targets
-
-# Microsoft Azure Build Output
-csx/
-*.build.csdef
-
-# Microsoft Azure Emulator
-ecf/
-rcf/
-
-# Windows Store app package directories and files
-AppPackages/
-BundleArtifacts/
-Package.StoreAssociation.xml
-_pkginfo.txt
-*.appx
-
-# Visual Studio cache files
-# files ending in .cache can be ignored
-*.[Cc]ache
-# but keep track of directories ending in .cache
-!?*.[Cc]ache/
-
-# Others
-ClientBin/
-~$*
-*~
-*.dbmdl
-*.dbproj.schemaview
-*.jfm
-*.pfx
-*.publishsettings
-orleans.codegen.cs
-
-# Including strong name files can present a security risk
-# (https://github.com/github/gitignore/pull/2483#issue-259490424)
-#*.snk
-
-# Since there are multiple workflows, uncomment next line to ignore bower_components
-# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
-#bower_components/
-
-# RIA/Silverlight projects
-Generated_Code/
-
-# Backup & report files from converting an old project file
-# to a newer Visual Studio version. Backup files are not needed,
-# because we have git ;-)
-_UpgradeReport_Files/
-Backup*/
-UpgradeLog*.XML
-UpgradeLog*.htm
-ServiceFabricBackup/
-*.rptproj.bak
-
-# SQL Server files
-*.mdf
-*.ldf
-*.ndf
-
-# Business Intelligence projects
-*.rdl.data
-*.bim.layout
-*.bim_*.settings
-*.rptproj.rsuser
-*- Backup*.rdl
-
-# Microsoft Fakes
-FakesAssemblies/
-
-# GhostDoc plugin setting file
-*.GhostDoc.xml
-
-# Node.js Tools for Visual Studio
-.ntvs_analysis.dat
-node_modules/
-
-# Visual Studio 6 build log
-*.plg
-
-# Visual Studio 6 workspace options file
-*.opt
-
-# Visual Studio 6 auto-generated workspace file (contains which files were open etc.)
-*.vbw
-
-# Visual Studio LightSwitch build output
-**/*.HTMLClient/GeneratedArtifacts
-**/*.DesktopClient/GeneratedArtifacts
-**/*.DesktopClient/ModelManifest.xml
-**/*.Server/GeneratedArtifacts
-**/*.Server/ModelManifest.xml
-_Pvt_Extensions
-
-# Paket dependency manager
-.paket/paket.exe
-paket-files/
-
-# FAKE - F# Make
-.fake/
-
-# JetBrains Rider
-.idea/
-*.sln.iml
-
-# CodeRush personal settings
-.cr/personal
-
-# Python Tools for Visual Studio (PTVS)
-__pycache__/
-*.pyc
-
-# Cake - Uncomment if you are using it
-# tools/**
-# !tools/packages.config
-
-# Tabs Studio
-*.tss
-
-# Telerik's JustMock configuration file
-*.jmconfig
-
-# BizTalk build output
-*.btp.cs
-*.btm.cs
-*.odx.cs
-*.xsd.cs
-
-# OpenCover UI analysis results
-OpenCover/
-
-# Azure Stream Analytics local run output
-ASALocalRun/
-
-# MSBuild Binary and Structured Log
-*.binlog
-
-# NVidia Nsight GPU debugger configuration file
-*.nvuser
-
-# MFractors (Xamarin productivity tool) working folder
-.mfractor/
-
-# Local History for Visual Studio
-.localhistory/
-
-# BeatPulse healthcheck temp database
-healthchecksdb
+# Coverage
+*.opencover.xml

Changelog.md

@@ -0,0 +1,90 @@
+### v2.0.1 (24-Mar-2021)
+
+- Fixed an issue where some exceptions with async stack traces generated on .NET 3.1 or earlier were not parsed and formatted correctly.
+- Fixed an issue where help text applied slightly incorrect formatting when displaying choices for enum-based parameters and properties.
+
+### v2.0 (21-Mar-2021)
+
+> Note: this major release includes many breaking changes.
+Please refer to the readme to find updated instructions and usage examples.
+
+- Renamed property `EnvironmentVariableName` to `EnvironmentVariable` on `CommandOption` attribute.
+- Removed most of schema validation checks that used to take place during application startup. Going forward, CliFx will be relying solely on its built-in set of Roslyn analyzers to catch common errors in command configuration.
+- Removed `ProgressTicker` utility. The recommended migration path is to use the [Spectre.Console](https://github.com/spectresystems/spectre.console) library which provides a wide array of console widgets and components. See [this wiki page](https://github.com/Tyrrrz/CliFx/wiki/Integrating-with-Spectre.Console) to learn how to integrate Spectre.Console with CliFx.
+- Removed `MemoryStreamWriter` utility as it's no longer used within CliFx.
+- Improved wording in all error messages.
+- Renamed some methods on `CliApplicationBuilder`:
+  - `UseTitle()` renamed to `SetTitle()`
+  - `UseExecutableName()` renamed to `SetExecutableName()`
+  - `UseVersionText()` renamed to `SetVersion()`
+  - `UseDescription()` renamed to `SetDescription()`
+- Changed the behavior of autogenerated help text:
+  - Changed the color scheme to a more neutral set of tones
+  - Assigned separate colors to parameters and options to make them visually stand out
+  - Usage section no longer lists usage formats of all descendant commands
+  - Command section now also lists available subcommands for each of the current command's subcommands
+- Changed the behavior of `[preview]` directive. Running the application with this directive will now also print all resolved environment variables, in addition to parsed command line arguments.
+- Reworked `IArgumentValueConverter`/`ArgumentValueConverter` into `BindingConverter`. Method `ConvertFrom(...)` has been renamed to `Convert(...)`.
+- Reworked `ArgumentValueValidator` into `BindingValidator`. This class exposes an abstract `Validate(...)` method that returns a nullable `BindingValidationError`. This class also provides utility methods `Ok()` and `Error(...)` to help create corresponding validation results.
+- Changed the type of `IConsole.Output` and `IConsole.Error` from `StreamWriter` to `ConsoleWriter`. This type derives from `StreamWriter` and additionally exposes a `Console` property that refers to the console instance that owns the stream. This change enables you to author extension methods scoped specifically to console output and error streams.
+- Changed the type of `IConsole.Input` from `StreamReader` to `ConsoleReader`. This type derives from `StreamReader` and additionally exposes a `Console` property that refers to the console instance that owns the stream. This change enables you to author extension methods scoped specifically to the console input stream.
+- Changed methods `IConsole.WithForegroundColor(...)`, `IConsole.WithBackgroundColor(...)`, and `IConsole.WithColors(...)` to return `IDisposable`, replacing the delegate parameter they previously had. You can wrap the returned `IDisposable` in a using statement to ensure that the console colors get reset back to their original values once the execution reaches the end of the block.
+- Renamed `IConsole.GetCancellationToken()` to `IConsole.RegisterCancellationHandler()`.
+- Reworked `VirtualConsole` into `FakeConsole`. This class no longer takes `CancellationToken` as a constructor parameter, but instead encapsulates its own instance of `CancellationTokenSource` that can be triggered using the provided `RequestCancellation()` method.
+- Removed `VirtualConsole.CreateBuffered()` and replaced it with the `FakeInMemoryConsole` class. This class derives from `FakeConsole` and uses in-memory standard input, output, and error streams. It also provides methods to easily read the data written to the streams.
+- Moved some types to different namespaces:
+  - `IConsole`/`FakeConsole`/`FakeInMemoryConsole` moved from `CliFx` to `CliFx.Infrastructure`
+  - `ITypeActivator`/`DefaultTypeActivator`/`DelegateTypeActivator` moved from `CliFx` to `CliFx.Infrastructure`
+  - `BindingValidator`/`BindingConverter` moved from `CliFx` to `CliFx.Extensibility`
+
+### v1.6 (06-Dec-2020)
+
+- Added support for custom value validators. You can now create a type that inherits from `CliFx.ArgumentValueValidator<T>` to implement reusable validation logic for command arguments. To use a validator, include it in the `Validators` property on the `CommandOption` or `CommandParameter` attribute. (Thanks [@Oleksandr Shustov](https://github.com/AlexandrShustov))
+- Added `CliFx.ArgumentValueConverter<T>` class that you can inherit from to implement custom value converters. `CliFx.IArgumentValueConverter` interface is still available, but it is recommended to inherit from the generic class instead, due to the type safety it provides. The interface may become internal or get removed in one of the future major versions.
+- Updated requirements for option names and short names: short names now must be letter characters (lowercase or uppercase), while names must now start with a letter character. This means option names can no longer start with a digit or a special character. This change makes it possible to pass negative number values without the need to quote them, i.e. `--my-number -5`.
+
+### v1.5 (23-Oct-2020)
+
+- Added pretty-printing for unhandled exceptions thrown from within the application. This makes the errors easier to parse visually and should help in troubleshooting. This change does not affect `CommandException`, as it already has special treatment. (Thanks [@Mårten Åsberg](https://github.com/89netraM))
+- Added support for custom value converters. You can now create a type that implements `CliFx.IArgumentValueConverter` and specify it as a converter for your parameters or options via the `Converter` named property. This should enable conversion between raw argument values and custom types which are not string-initializable. (Thanks [@Oleksandr Shustov](https://github.com/AlexandrShustov))
+- Improved help text so that it also shows minimal usage examples for child and descendant commands, besides the actual command it was requested on. This should improve user experience for applications with many nested commands. (Thanks [@Nikiforov Alexey](https://github.com/NikiforovAll))
+
+### v1.4 (20-Aug-2020)
+
+- Added `VirtualConsole.CreateBuffered()` method to simplify test setup when using in-memory backing stores for output and error streams. Please refer to the readme for updated recommendations on how to test applications built with CliFx.
+- Added generic `CliApplicationBuilder.AddCommand<TCommand>()`. This overload simplifies adding commands one-by-one as it also checks that the type implements `ICommand`.
+
+### v1.3.2 (31-Jul-2020)
+
+- Fixed an issue where a command was incorrectly allowed to execute when the user did not specify any value for a non-scalar parameter. Since they are always required, a parameter needs to be bound to at least one value. (Thanks [@Daniel Hix](https://github.com/ADustyOldMuffin))
+- Fixed an issue where `CliApplication.RunAsync(...)` threw `ArgumentException` if there were two environment variables, whose names differed only in case. Environment variable names are now treated case-sensitively. (Thanks [@Ron Myers](https://github.com/ron-myers))
+
+### v1.3.1 (19-Jul-2020)
+
+- Running the application with the debug directive (`myapp [debug]`) will now also try to launch a debugger instance. In most cases it will save time as you won't need to attach the debugger manually. (Thanks [@Volodymyr Shkolka](https://github.com/BlackGad))
+- Fixed an issue where unhandled generic exceptions (i.e. not `CommandException`) sometimes caused the application to incorrectly return successful exit code due to an overflow issue on Unix systems. Starting from this version, all unhandled generic exceptions will produce `1` as the exit code when thrown. Instances of `CommandException` can still be configured to return any specified exit code, but it's recommended to constrain the values between `1` and `255` to avoid overflow issues. (Thanks [@Ihor Nechyporuk](https://github.com/inech))
+
+### v1.3 (23-May-2020)
+
+- Changed analyzers to report errors instead of warnings. If you find that some analyzer works incorrectly, please report it on GitHub. You can also configure inspection severity overrides in your project if you need to.
+- Improved help text by showing default values for non-required options. This only works on types that have a custom override for `ToString()` method. Additionally, if the type implements `IFormattable`, the overload with a format provider will be used instead. (Thanks [@Domn Werner](https://github.com/domn1995))
+- Changed default version text to only show 3 version components instead of 4, if the last component (revision) is not specified or is zero. This makes the default version text compliant with semantic versioning.
+- Fixed an issue where it was possible to define a command with an option that has the same name or short name as built-in help or version options. Previously it would lead to the user-defined option being ignored in favor of the built-in option. Now this will throw an exception instead.
+- Changed the underlying representation of `StreamReader`/`StreamWriter` objects used in `SystemConsole` and `VirtualConsole` to be thread-safe.
+
+### v1.2 (11-May-2020)
+
+- Added built-in Roslyn analyzers that help catch incorrect usage of the library. Currently, all analyzers report issues as warnings so as to not prevent the project from building. In the future that may change.
+- Added an optional parameter to `new CommandException(...)` called `showHelp` which can be used to instruct CliFx to show help for the current command after printing the error. (Thanks [@Domn Werner](https://github.com/domn1995))
+- Improved help text shown for enum options and parameters by providing the list of valid values that the enum can accept. (Thanks [@Domn Werner](https://github.com/domn1995))
+- Fixed an issue where it was possible to set an option without providing a value, while the option was marked as required.
+- Fixed an issue where it was possible to configure an option with an empty name or a name consisting of a single character. If you want to use a single character as a name, you should set the option's short name instead.
+- Added `CursorLeft` and `CursorTop` properties to `IConsole` and its implementations. In `VirtualConsole`, these are just auto-properties.
+- Improved exception messages.
+- Improved exceptions related to user input by also showing help text after the error message. (Thanks [@Domn Werner](https://github.com/domn1995))
+
+### v1.1 (16-Mar-2020)
+
+- Changed `IConsole` interface (and as a result, `SystemConsole` and `VirtualConsole`) to support writing binary data. Instead of `TextReader`/`TextWriter` instances, the streams are now exposed as `StreamReader`/`StreamWriter` which provide the `BaseStream` property that allows raw access. Existing usages inside commands should remain the same because `StreamReader`/`StreamWriter` are compatible with their base classes `TextReader`/`TextWriter`, but if you were using `VirtualConsole` in tests, you may have to update it to the new API. Refer to the readme for more info.
+- Changed argument binding behavior so that an error is produced if the user provides an argument that doesn't match with any parameter or option. This is done in order to improve user experience, as otherwise the user may make a typo without knowing that their input wasn't taken into account.
+- Changed argument binding behavior so that options can be set to multiple argument values while specifying them with mixed naming. For example, `--option value1 -o value2 --option value3` would result in the option being set to corresponding three values, assuming `--option` and `-o` match with the same option.

CliFx.Analyzers.Tests/CliFx.Analyzers.Tests.csproj

@@ -0,0 +1,30 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net5.0</TargetFramework>
+    <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
+    <CollectCoverage>true</CollectCoverage>
+    <CoverletOutputFormat>opencover</CoverletOutputFormat>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Content Include="xunit.runner.json" CopyToOutputDirectory="PreserveNewest" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="GitHubActionsTestLogger" Version="1.2.0" />
+    <PackageReference Include="FluentAssertions" Version="5.10.3" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.9.1" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="3.4.0" />
+    <PackageReference Include="xunit" Version="2.4.0" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3" PrivateAssets="all" />
+    <PackageReference Include="coverlet.msbuild" Version="3.0.3" PrivateAssets="all" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\CliFx.Analyzers\CliFx.Analyzers.csproj" />
+    <ProjectReference Include="..\CliFx\CliFx.csproj" />
+  </ItemGroup>
+
+</Project>

CliFx.Analyzers.Tests/CommandMustBeAnnotatedAnalyzerSpecs.cs

@@ -0,0 +1,72 @@
+using CliFx.Analyzers.Tests.Utils;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Xunit;
+
+namespace CliFx.Analyzers.Tests
+{
+    public class CommandMustBeAnnotatedAnalyzerSpecs
+    {
+        private static DiagnosticAnalyzer Analyzer { get; } = new CommandMustBeAnnotatedAnalyzer();
+
+        [Fact]
+        public void Analyzer_reports_an_error_if_a_command_is_not_annotated_with_the_command_attribute()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+public class MyCommand : ICommand
+{
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().ProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_if_a_command_is_annotated_with_the_command_attribute()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public abstract class MyCommand : ICommand
+{
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_if_a_command_is_implemented_as_an_abstract_class()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+public abstract class MyCommand : ICommand
+{
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_on_a_class_that_is_not_a_command()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+public class Foo
+{
+    public int Bar { get; set; } = 5;
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+    }
+}

CliFx.Analyzers.Tests/CommandMustImplementInterfaceAnalyzerSpecs.cs

@@ -0,0 +1,58 @@
+using CliFx.Analyzers.Tests.Utils;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Xunit;
+
+namespace CliFx.Analyzers.Tests
+{
+    public class CommandMustImplementInterfaceAnalyzerSpecs
+    {
+        private static DiagnosticAnalyzer Analyzer { get; } = new CommandMustImplementInterfaceAnalyzer();
+
+        [Fact]
+        public void Analyzer_reports_an_error_if_a_command_does_not_implement_ICommand_interface()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand
+{
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().ProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_if_a_command_implements_ICommand_interface()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_on_a_class_that_is_not_a_command()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+public class Foo
+{
+    public int Bar { get; set; } = 5;
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+    }
+}

CliFx.Analyzers.Tests/GeneralSpecs.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Linq;
+using FluentAssertions;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Xunit;
+
+namespace CliFx.Analyzers.Tests
+{
+    public class GeneralSpecs
+    {
+        [Fact]
+        public void All_analyzers_have_unique_diagnostic_IDs()
+        {
+            // Arrange
+            var analyzers = typeof(AnalyzerBase)
+                .Assembly
+                .GetTypes()
+                .Where(t => !t.IsAbstract && t.IsAssignableTo(typeof(DiagnosticAnalyzer)))
+                .Select(t => (DiagnosticAnalyzer) Activator.CreateInstance(t)!)
+                .ToArray();
+
+            // Act
+            var diagnosticIds = analyzers
+                .SelectMany(a => a.SupportedDiagnostics.Select(d => d.Id))
+                .ToArray();
+
+            // Assert
+            diagnosticIds.Should().OnlyHaveUniqueItems();
+        }
+    }
+}

CliFx.Analyzers.Tests/OptionMustBeInsideCommandAnalyzerSpecs.cs

@@ -0,0 +1,80 @@
+using CliFx.Analyzers.Tests.Utils;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Xunit;
+
+namespace CliFx.Analyzers.Tests
+{
+    public class OptionMustBeInsideCommandAnalyzerSpecs
+    {
+        private static DiagnosticAnalyzer Analyzer { get; } = new OptionMustBeInsideCommandAnalyzer();
+
+        [Fact]
+        public void Analyzer_reports_an_error_if_an_option_is_inside_a_class_that_is_not_a_command()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+public class MyClass
+{
+    [CommandOption(""foo"")]
+    public string Foo { get; set; }
+}";
+
+            // Act & assert
+            Analyzer.Should().ProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_if_an_option_is_inside_a_command()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandOption(""foo"")]
+    public string Foo { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_if_an_option_is_inside_an_abstract_class()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+public abstract class MyCommand
+{
+    [CommandOption(""foo"")]
+    public string Foo { get; set; }
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_on_a_property_that_is_not_an_option()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    public string Foo { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+    }
+}

CliFx.Analyzers.Tests/OptionMustHaveNameOrShortNameAnalyzerSpecs.cs

@@ -0,0 +1,86 @@
+using CliFx.Analyzers.Tests.Utils;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Xunit;
+
+namespace CliFx.Analyzers.Tests
+{
+    public class OptionMustHaveNameOrShortNameAnalyzerSpecs
+    {
+        private static DiagnosticAnalyzer Analyzer { get; } = new OptionMustHaveNameOrShortNameAnalyzer();
+
+        [Fact]
+        public void Analyzer_reports_an_error_if_an_option_does_not_have_a_name_or_short_name()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandOption(null)]
+    public string Foo { get; set; }
+    
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().ProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_if_an_option_has_a_name()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandOption(""foo"")]
+    public string Foo { get; set; }
+    
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_if_an_option_has_a_short_name()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandOption('f')]
+    public string Foo { get; set; }
+    
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_on_a_property_that_is_not_an_option()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    public string Foo { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+    }
+}

CliFx.Analyzers.Tests/OptionMustHaveUniqueNameAnalyzerSpecs.cs

@@ -0,0 +1,92 @@
+using CliFx.Analyzers.Tests.Utils;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Xunit;
+
+namespace CliFx.Analyzers.Tests
+{
+    public class OptionMustHaveUniqueNameAnalyzerSpecs
+    {
+        private static DiagnosticAnalyzer Analyzer { get; } = new OptionMustHaveUniqueNameAnalyzer();
+
+        [Fact]
+        public void Analyzer_reports_an_error_if_an_option_has_the_same_name_as_another_option()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandOption(""foo"")]
+    public string Foo { get; set; }
+    
+    [CommandOption(""foo"")]
+    public string Bar { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().ProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_if_an_option_has_a_unique_name()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandOption(""foo"")]
+    public string Foo { get; set; }
+    
+    [CommandOption(""bar"")]
+    public string Bar { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_if_an_option_does_not_have_a_name()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandOption('f')]
+    public string Foo { get; set; }
+    
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_on_a_property_that_is_not_an_option()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    public string Foo { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+    }
+}

CliFx.Analyzers.Tests/OptionMustHaveUniqueShortNameAnalyzerSpecs.cs

@@ -0,0 +1,114 @@
+using CliFx.Analyzers.Tests.Utils;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Xunit;
+
+namespace CliFx.Analyzers.Tests
+{
+    public class OptionMustHaveUniqueShortNameAnalyzerSpecs
+    {
+        private static DiagnosticAnalyzer Analyzer { get; } = new OptionMustHaveUniqueShortNameAnalyzer();
+
+        [Fact]
+        public void Analyzer_reports_an_error_if_an_option_has_the_same_short_name_as_another_option()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandOption('f')]
+    public string Foo { get; set; }
+    
+    [CommandOption('f')]
+    public string Bar { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().ProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_if_an_option_has_a_unique_short_name()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandOption('f')]
+    public string Foo { get; set; }
+    
+    [CommandOption('b')]
+    public string Bar { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_if_an_option_has_a_short_name_which_is_unique_only_in_casing()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandOption('f')]
+    public string Foo { get; set; }
+    
+    [CommandOption('F')]
+    public string Bar { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_if_an_option_does_not_have_a_short_name()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandOption(""foo"")]
+    public string Foo { get; set; }
+    
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_on_a_property_that_is_not_an_option()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    public string Foo { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+    }
+}

CliFx.Analyzers.Tests/OptionMustHaveValidConverterAnalyzerSpecs.cs

@@ -0,0 +1,96 @@
+using CliFx.Analyzers.Tests.Utils;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Xunit;
+
+namespace CliFx.Analyzers.Tests
+{
+    public class OptionMustHaveValidConverterAnalyzerSpecs
+    {
+        private static DiagnosticAnalyzer Analyzer { get; } = new OptionMustHaveValidConverterAnalyzer();
+
+        [Fact]
+        public void Analyzer_reports_an_error_if_the_specified_option_converter_does_not_derive_from_BindingConverter()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+public class MyConverter
+{
+    public string Convert(string rawValue) => rawValue;
+}
+
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandOption(""foo"", Converter = typeof(MyConverter))]
+    public string Foo { get; set; }
+    
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().ProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_if_the_specified_option_converter_derives_from_BindingConverter()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+public class MyConverter : BindingConverter<string>
+{
+    public override string Convert(string rawValue) => rawValue;
+}
+
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandOption(""foo"", Converter = typeof(MyConverter))]
+    public string Foo { get; set; }
+    
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_if_an_option_does_not_have_a_converter()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandOption(""foo"")]
+    public string Foo { get; set; }
+    
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_on_a_property_that_is_not_an_option()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    public string Foo { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+    }
+}

CliFx.Analyzers.Tests/OptionMustHaveValidNameAnalyzerSpecs.cs

@@ -0,0 +1,105 @@
+using CliFx.Analyzers.Tests.Utils;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Xunit;
+
+namespace CliFx.Analyzers.Tests
+{
+    public class OptionMustHaveValidNameAnalyzerSpecs
+    {
+        private static DiagnosticAnalyzer Analyzer { get; } = new OptionMustHaveValidNameAnalyzer();
+
+        [Fact]
+        public void Analyzer_reports_an_error_if_an_option_has_a_name_which_is_too_short()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandOption(""f"")]
+    public string Foo { get; set; }
+    
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().ProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_reports_an_error_if_an_option_has_a_name_that_starts_with_a_non_letter_character()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandOption(""1foo"")]
+    public string Foo { get; set; }
+    
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().ProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_if_an_option_has_a_valid_name()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandOption(""foo"")]
+    public string Foo { get; set; }
+    
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_if_an_option_does_not_have_a_name()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandOption('f')]
+    public string Foo { get; set; }
+    
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_on_a_property_that_is_not_an_option()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    public string Foo { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+    }
+}

CliFx.Analyzers.Tests/OptionMustHaveValidShortNameAnalyzerSpecs.cs

@@ -0,0 +1,86 @@
+using CliFx.Analyzers.Tests.Utils;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Xunit;
+
+namespace CliFx.Analyzers.Tests
+{
+    public class OptionMustHaveValidShortNameAnalyzerSpecs
+    {
+        private static DiagnosticAnalyzer Analyzer { get; } = new OptionMustHaveValidShortNameAnalyzer();
+
+        [Fact]
+        public void Analyzer_reports_an_error_if_an_option_has_a_short_name_which_is_not_a_letter_character()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandOption('1')]
+    public string Foo { get; set; }
+    
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().ProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_if_an_option_has_a_valid_short_name()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandOption('f')]
+    public string Foo { get; set; }
+    
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_if_an_option_does_not_have_a_short_name()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandOption(""foo"")]
+    public string Foo { get; set; }
+    
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_on_a_property_that_is_not_an_option()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    public string Foo { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+    }
+}

CliFx.Analyzers.Tests/OptionMustHaveValidValidatorsAnalyzerSpecs.cs

@@ -0,0 +1,96 @@
+using CliFx.Analyzers.Tests.Utils;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Xunit;
+
+namespace CliFx.Analyzers.Tests
+{
+    public class OptionMustHaveValidValidatorsAnalyzerSpecs
+    {
+        private static DiagnosticAnalyzer Analyzer { get; } = new OptionMustHaveValidValidatorsAnalyzer();
+
+        [Fact]
+        public void Analyzer_reports_an_error_if_one_of_the_specified_option_validators_does_not_derive_from_BindingValidator()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+public class MyValidator
+{
+    public void Validate(string value) {}
+}
+
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandOption(""foo"", Validators = new[] {typeof(MyValidator)})]
+    public string Foo { get; set; }
+    
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().ProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_if_all_specified_option_validators_derive_from_BindingValidator()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+public class MyValidator : BindingValidator<string>
+{
+    public override BindingValidationError Validate(string value) => Ok();
+}
+
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandOption(""foo"", Validators = new[] {typeof(MyValidator)})]
+    public string Foo { get; set; }
+    
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_if_an_option_does_not_have_validators()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandOption(""foo"")]
+    public string Foo { get; set; }
+    
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_on_a_property_that_is_not_an_option()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    public string Foo { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+    }
+}

CliFx.Analyzers.Tests/ParameterMustBeInsideCommandAnalyzerSpecs.cs

@@ -0,0 +1,80 @@
+using CliFx.Analyzers.Tests.Utils;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Xunit;
+
+namespace CliFx.Analyzers.Tests
+{
+    public class ParameterMustBeInsideCommandAnalyzerSpecs
+    {
+        private static DiagnosticAnalyzer Analyzer { get; } = new ParameterMustBeInsideCommandAnalyzer();
+
+        [Fact]
+        public void Analyzer_reports_an_error_if_a_parameter_is_inside_a_class_that_is_not_a_command()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+public class MyClass
+{
+    [CommandParameter(0)]
+    public string Foo { get; set; }
+}";
+
+            // Act & assert
+            Analyzer.Should().ProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_if_a_parameter_is_inside_a_command()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandParameter(0)]
+    public string Foo { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_if_a_parameter_is_inside_an_abstract_class()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+public abstract class MyCommand
+{
+    [CommandParameter(0)]
+    public string Foo { get; set; }
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_on_a_property_that_is_not_a_parameter()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    public string Foo { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+    }
+}

CliFx.Analyzers.Tests/ParameterMustBeLastIfNonScalarAnalyzerSpecs.cs

@@ -0,0 +1,95 @@
+using CliFx.Analyzers.Tests.Utils;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Xunit;
+
+namespace CliFx.Analyzers.Tests
+{
+    public class ParameterMustBeLastIfNonScalarAnalyzerSpecs
+    {
+        private static DiagnosticAnalyzer Analyzer { get; } = new ParameterMustBeLastIfNonScalarAnalyzer();
+
+        [Fact]
+        public void Analyzer_reports_an_error_if_a_non_scalar_parameter_is_not_last_in_order()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandParameter(0)]
+    public string[] Foo { get; set; }
+    
+    [CommandParameter(1)]
+    public string Bar { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().ProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_if_a_non_scalar_parameter_is_last_in_order()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandParameter(0)]
+    public string Foo { get; set; }
+    
+    [CommandParameter(1)]
+    public string[] Bar { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_if_no_non_scalar_parameters_are_defined()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandParameter(0)]
+    public string Foo { get; set; }
+    
+    [CommandParameter(1)]
+    public string Bar { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_on_a_property_that_is_not_a_parameter()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    public string Foo { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+    }
+}

CliFx.Analyzers.Tests/ParameterMustBeSingleIfNonScalarAnalyzerSpecs.cs

@@ -0,0 +1,95 @@
+using CliFx.Analyzers.Tests.Utils;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Xunit;
+
+namespace CliFx.Analyzers.Tests
+{
+    public class ParameterMustBeSingleIfNonScalarAnalyzerSpecs
+    {
+        private static DiagnosticAnalyzer Analyzer { get; } = new ParameterMustBeSingleIfNonScalarAnalyzer();
+
+        [Fact]
+        public void Analyzer_reports_an_error_if_more_than_one_non_scalar_parameters_are_defined()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandParameter(0)]
+    public string[] Foo { get; set; }
+    
+    [CommandParameter(1)]
+    public string[] Bar { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().ProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_if_only_one_non_scalar_parameter_is_defined()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandParameter(0)]
+    public string Foo { get; set; }
+    
+    [CommandParameter(1)]
+    public string[] Bar { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_if_no_non_scalar_parameters_are_defined()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandParameter(0)]
+    public string Foo { get; set; }
+    
+    [CommandParameter(1)]
+    public string Bar { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_on_a_property_that_is_not_a_parameter()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    public string Foo { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+    }
+}

CliFx.Analyzers.Tests/ParameterMustHaveUniqueNameAnalyzerSpecs.cs

@@ -0,0 +1,73 @@
+using CliFx.Analyzers.Tests.Utils;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Xunit;
+
+namespace CliFx.Analyzers.Tests
+{
+    public class ParameterMustHaveUniqueNameAnalyzerSpecs
+    {
+        private static DiagnosticAnalyzer Analyzer { get; } = new ParameterMustHaveUniqueNameAnalyzer();
+
+        [Fact]
+        public void Analyzer_reports_an_error_if_a_parameter_has_the_same_name_as_another_parameter()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandParameter(0, Name = ""foo"")]
+    public string Foo { get; set; }
+    
+    [CommandParameter(1, Name = ""foo"")]
+    public string Bar { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().ProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_if_a_parameter_has_unique_name()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandParameter(0, Name = ""foo"")]
+    public string Foo { get; set; }
+    
+    [CommandParameter(1, Name = ""bar"")]
+    public string Bar { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_on_a_property_that_is_not_a_parameter()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    public string Foo { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+    }
+}

CliFx.Analyzers.Tests/ParameterMustHaveUniqueOrderAnalyzerSpecs.cs

@@ -0,0 +1,73 @@
+using CliFx.Analyzers.Tests.Utils;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Xunit;
+
+namespace CliFx.Analyzers.Tests
+{
+    public class ParameterMustHaveUniqueOrderAnalyzerSpecs
+    {
+        private static DiagnosticAnalyzer Analyzer { get; } = new ParameterMustHaveUniqueOrderAnalyzer();
+
+        [Fact]
+        public void Analyzer_reports_an_error_if_a_parameter_has_the_same_order_as_another_parameter()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandParameter(0)]
+    public string Foo { get; set; }
+    
+    [CommandParameter(0)]
+    public string Bar { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().ProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_if_a_parameter_has_unique_order()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandParameter(0)]
+    public string Foo { get; set; }
+    
+    [CommandParameter(1)]
+    public string Bar { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_on_a_property_that_is_not_a_parameter()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    public string Foo { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+    }
+}

CliFx.Analyzers.Tests/ParameterMustHaveValidConverterAnalyzerSpecs.cs

@@ -0,0 +1,96 @@
+using CliFx.Analyzers.Tests.Utils;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Xunit;
+
+namespace CliFx.Analyzers.Tests
+{
+    public class ParameterMustHaveValidConverterAnalyzerSpecs
+    {
+        private static DiagnosticAnalyzer Analyzer { get; } = new ParameterMustHaveValidConverterAnalyzer();
+
+        [Fact]
+        public void Analyzer_reports_an_error_if_the_specified_parameter_converter_does_not_derive_from_BindingConverter()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+public class MyConverter
+{
+    public string Convert(string rawValue) => rawValue;
+}
+
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandParameter(0, Converter = typeof(MyConverter))]
+    public string Foo { get; set; }
+    
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().ProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_if_the_specified_parameter_converter_derives_from_BindingConverter()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+public class MyConverter : BindingConverter<string>
+{
+    public override string Convert(string rawValue) => rawValue;
+}
+
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandParameter(0, Converter = typeof(MyConverter))]
+    public string Foo { get; set; }
+    
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_if_a_parameter_does_not_have_a_converter()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandParameter(0)]
+    public string Foo { get; set; }
+    
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_on_a_property_that_is_not_a_parameter()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    public string Foo { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+    }
+}

CliFx.Analyzers.Tests/ParameterMustHaveValidValidatorsAnalyzerSpecs.cs

@@ -0,0 +1,96 @@
+using CliFx.Analyzers.Tests.Utils;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Xunit;
+
+namespace CliFx.Analyzers.Tests
+{
+    public class ParameterMustHaveValidValidatorsAnalyzerSpecs
+    {
+        private static DiagnosticAnalyzer Analyzer { get; } = new ParameterMustHaveValidValidatorsAnalyzer();
+
+        [Fact]
+        public void Analyzer_reports_an_error_if_one_of_the_specified_parameter_validators_does_not_derive_from_BindingValidator()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+public class MyValidator
+{
+    public void Validate(string value) {}
+}
+
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandParameter(0, Validators = new[] {typeof(MyValidator)})]
+    public string Foo { get; set; }
+    
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().ProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_if_all_specified_parameter_validators_derive_from_BindingValidator()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+public class MyValidator : BindingValidator<string>
+{
+    public override BindingValidationError Validate(string value) => Ok();
+}
+
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandParameter(0, Validators = new[] {typeof(MyValidator)})]
+    public string Foo { get; set; }
+    
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_if_a_parameter_does_not_have_validators()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandParameter(0)]
+    public string Foo { get; set; }
+    
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_on_a_property_that_is_not_a_parameter()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    public string Foo { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+    }
+}

CliFx.Analyzers.Tests/SystemConsoleShouldBeAvoidedAnalyzerSpecs.cs

@@ -0,0 +1,108 @@
+using CliFx.Analyzers.Tests.Utils;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Xunit;
+
+namespace CliFx.Analyzers.Tests
+{
+    public class SystemConsoleShouldBeAvoidedAnalyzerSpecs
+    {
+        private static DiagnosticAnalyzer Analyzer { get; } = new SystemConsoleShouldBeAvoidedAnalyzer();
+
+        [Fact]
+        public void Analyzer_reports_an_error_if_a_command_calls_a_method_on_SystemConsole()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    public ValueTask ExecuteAsync(IConsole console)
+    {
+        Console.WriteLine(""Hello world"");
+        return default;
+    }
+}";
+
+            // Act & assert
+            Analyzer.Should().ProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_reports_an_error_if_a_command_accesses_a_property_on_SystemConsole()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    public ValueTask ExecuteAsync(IConsole console)
+    {
+        Console.ForegroundColor = ConsoleColor.Black;
+        return default;
+    }
+}";
+            // Act & assert
+            Analyzer.Should().ProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_reports_an_error_if_a_command_calls_a_method_on_a_property_of_SystemConsole()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    public ValueTask ExecuteAsync(IConsole console)
+    {
+        Console.Error.WriteLine(""Hello world"");
+        return default;
+    }
+}";
+
+            // Act & assert
+            Analyzer.Should().ProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_if_a_command_interacts_with_the_console_through_IConsole()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    public ValueTask ExecuteAsync(IConsole console)
+    {
+        console.Output.WriteLine(""Hello world"");
+        return default;
+    }
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+
+        [Fact]
+        public void Analyzer_does_not_report_an_error_if_IConsole_is_not_available_in_the_current_method()
+        {
+            // Arrange
+            // language=cs
+            const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    public void SomeOtherMethod() => Console.WriteLine(""Test"");
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+            // Act & assert
+            Analyzer.Should().NotProduceDiagnostics(code);
+        }
+    }
+}

CliFx.Analyzers.Tests/Utils/AnalyzerAssertions.cs

@@ -0,0 +1,174 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using FluentAssertions.Execution;
+using FluentAssertions.Primitives;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Text;
+
+namespace CliFx.Analyzers.Tests.Utils
+{
+    internal class AnalyzerAssertions : ReferenceTypeAssertions<DiagnosticAnalyzer, AnalyzerAssertions>
+    {
+        protected override string Identifier { get; } = "analyzer";
+
+        public AnalyzerAssertions(DiagnosticAnalyzer analyzer)
+            : base(analyzer)
+        {
+        }
+
+        private Compilation Compile(string sourceCode)
+        {
+            // Get default system namespaces
+            var defaultSystemNamespaces = new[]
+            {
+                "System",
+                "System.Collections.Generic",
+                "System.Threading.Tasks"
+            };
+
+            // Get default CliFx namespaces
+            var defaultCliFxNamespaces = typeof(ICommand)
+                .Assembly
+                .GetTypes()
+                .Where(t => t.IsPublic)
+                .Select(t => t.Namespace)
+                .Distinct()
+                .ToArray();
+
+            // Append default imports to the source code
+            var sourceCodeWithUsings =
+                string.Join(Environment.NewLine, defaultSystemNamespaces.Select(n => $"using {n};")) +
+                string.Join(Environment.NewLine, defaultCliFxNamespaces.Select(n => $"using {n};")) +
+                Environment.NewLine +
+                sourceCode;
+
+            // Parse the source code
+            var ast = SyntaxFactory.ParseSyntaxTree(
+                SourceText.From(sourceCodeWithUsings),
+                CSharpParseOptions.Default
+            );
+
+            // Compile the code to IL
+            var compilation = CSharpCompilation.Create(
+                "CliFxTests_DynamicAssembly_" + Guid.NewGuid(),
+                new[] {ast},
+                new[]
+                {
+                    MetadataReference.CreateFromFile(Assembly.Load("netstandard").Location),
+                    MetadataReference.CreateFromFile(Assembly.Load("System.Runtime").Location),
+                    MetadataReference.CreateFromFile(typeof(object).Assembly.Location),
+                    MetadataReference.CreateFromFile(typeof(Console).Assembly.Location),
+                    MetadataReference.CreateFromFile(typeof(ICommand).Assembly.Location)
+                },
+                // DLL to avoid having to define the Main() method
+                new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)
+            );
+
+            var compilationErrors = compilation
+                .GetDiagnostics()
+                .Where(d => d.Severity >= DiagnosticSeverity.Error)
+                .ToArray();
+
+            if (compilationErrors.Any())
+            {
+                throw new InvalidOperationException(
+                    "Failed to compile code." +
+                    Environment.NewLine +
+                    string.Join(Environment.NewLine, compilationErrors.Select(e => e.ToString()))
+                );
+            }
+
+            return compilation;
+        }
+
+        private IReadOnlyList<Diagnostic> GetProducedDiagnostics(string sourceCode)
+        {
+            var analyzers = ImmutableArray.Create(Subject);
+            var compilation = Compile(sourceCode);
+
+            return compilation
+                .WithAnalyzers(analyzers)
+                .GetAnalyzerDiagnosticsAsync(analyzers, default)
+                .GetAwaiter()
+                .GetResult();
+        }
+
+        public void ProduceDiagnostics(string sourceCode)
+        {
+            var expectedDiagnostics = Subject.SupportedDiagnostics;
+            var producedDiagnostics = GetProducedDiagnostics(sourceCode);
+
+            var expectedDiagnosticIds = expectedDiagnostics.Select(d => d.Id).Distinct().ToArray();
+            var producedDiagnosticIds = producedDiagnostics.Select(d => d.Id).Distinct().ToArray();
+
+            var result =
+                expectedDiagnosticIds.Intersect(producedDiagnosticIds).Count() ==
+                expectedDiagnosticIds.Length;
+
+            Execute.Assertion.ForCondition(result).FailWith(() =>
+            {
+                var buffer = new StringBuilder();
+
+                buffer.AppendLine("Expected and produced diagnostics do not match.");
+                buffer.AppendLine();
+
+                buffer.AppendLine("Expected diagnostics:");
+
+                foreach (var expectedDiagnostic in expectedDiagnostics)
+                {
+                    buffer.Append("  - ");
+                    buffer.Append(expectedDiagnostic.Id);
+                    buffer.AppendLine();
+                }
+
+                buffer.AppendLine();
+
+                buffer.AppendLine("Produced diagnostics:");
+
+                foreach (var producedDiagnostic in producedDiagnostics)
+                {
+                    buffer.Append("  - ");
+                    buffer.Append(producedDiagnostic);
+                }
+
+                return new FailReason(buffer.ToString());
+            });
+        }
+
+        public void NotProduceDiagnostics(string sourceCode)
+        {
+            var producedDiagnostics = GetProducedDiagnostics(sourceCode);
+
+            var result = !producedDiagnostics.Any();
+
+            Execute.Assertion.ForCondition(result).FailWith(() =>
+            {
+                var buffer = new StringBuilder();
+
+                buffer.AppendLine("Expected no produced diagnostics.");
+                buffer.AppendLine();
+
+                buffer.AppendLine("Produced diagnostics:");
+
+                foreach (var producedDiagnostic in producedDiagnostics)
+                {
+                    buffer.Append("  - ");
+                    buffer.Append(producedDiagnostic);
+                }
+
+                return new FailReason(buffer.ToString());
+            });
+        }
+    }
+
+    internal static class AnalyzerAssertionsExtensions
+    {
+        public static AnalyzerAssertions Should(this DiagnosticAnalyzer analyzer) => new(analyzer);
+    }
+}

CliFx.Analyzers.Tests/xunit.runner.json

@@ -0,0 +1,5 @@
+{
+  "$schema": "https://xunit.net/schema/current/xunit.runner.schema.json",
+  "methodDisplayOptions": "all",
+  "methodDisplay": "method"
+}

CliFx.Analyzers/AnalyzerBase.cs

@@ -0,0 +1,40 @@
+using System.Collections.Immutable;
+using CliFx.Analyzers.Utils.Extensions;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace CliFx.Analyzers
+{
+    public abstract class AnalyzerBase : DiagnosticAnalyzer
+    {
+        public DiagnosticDescriptor SupportedDiagnostic { get; }
+
+        public sealed override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; }
+
+        protected AnalyzerBase(
+            string diagnosticTitle,
+            string diagnosticMessage,
+            DiagnosticSeverity diagnosticSeverity = DiagnosticSeverity.Error)
+        {
+            SupportedDiagnostic = new DiagnosticDescriptor(
+                "CliFx_" + GetType().Name.TrimEnd("Analyzer"),
+                diagnosticTitle,
+                diagnosticMessage,
+                "CliFx",
+                diagnosticSeverity,
+                true
+            );
+
+            SupportedDiagnostics = ImmutableArray.Create(SupportedDiagnostic);
+        }
+
+        protected Diagnostic CreateDiagnostic(Location location) =>
+            Diagnostic.Create(SupportedDiagnostic, location);
+
+        public override void Initialize(AnalysisContext context)
+        {
+            context.EnableConcurrentExecution();
+            context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+        }
+    }
+}

CliFx.Analyzers/CliFx.Analyzers.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netstandard2.0</TargetFramework>
+    <Nullable>annotations</Nullable>
+    <NoWarn>$(NoWarn);RS1025;RS1026</NoWarn>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="3.4.0" PrivateAssets="all" />
+  </ItemGroup>
+
+</Project>

CliFx.Analyzers/CommandMustBeAnnotatedAnalyzer.cs

@@ -0,0 +1,54 @@
+using System.Linq;
+using CliFx.Analyzers.ObjectModel;
+using CliFx.Analyzers.Utils.Extensions;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace CliFx.Analyzers
+{
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public class CommandMustBeAnnotatedAnalyzer : AnalyzerBase
+    {
+        public CommandMustBeAnnotatedAnalyzer()
+            : base(
+                $"Commands must be annotated with `{SymbolNames.CliFxCommandAttribute}`",
+                $"This type must be annotated with `{SymbolNames.CliFxCommandAttribute}` in order to be a valid command.")
+        {
+        }
+
+        private void Analyze(
+            SyntaxNodeAnalysisContext context,
+            ClassDeclarationSyntax classDeclaration,
+            ITypeSymbol type)
+        {
+            // Ignore abstract classes, because they may be used to define
+            // base implementations for commands, in which case the command
+            // attribute doesn't make sense.
+            if (type.IsAbstract)
+                return;
+
+            var implementsCommandInterface = type
+                .AllInterfaces
+                .Any(s => s.DisplayNameMatches(SymbolNames.CliFxCommandInterface));
+
+            var hasCommandAttribute = type
+                .GetAttributes()
+                .Select(a => a.AttributeClass)
+                .Any(s => s.DisplayNameMatches(SymbolNames.CliFxCommandAttribute));
+
+            // If the interface is implemented, but the attribute is missing,
+            // then it's very likely a user error.
+            if (implementsCommandInterface && !hasCommandAttribute)
+            {
+                context.ReportDiagnostic(CreateDiagnostic(classDeclaration.GetLocation()));
+            }
+        }
+
+        public override void Initialize(AnalysisContext context)
+        {
+            base.Initialize(context);
+            context.HandleClassDeclaration(Analyze);
+        }
+    }
+}

CliFx.Analyzers/CommandMustImplementInterfaceAnalyzer.cs

@@ -0,0 +1,48 @@
+using System.Linq;
+using CliFx.Analyzers.ObjectModel;
+using CliFx.Analyzers.Utils.Extensions;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace CliFx.Analyzers
+{
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public class CommandMustImplementInterfaceAnalyzer : AnalyzerBase
+    {
+        public CommandMustImplementInterfaceAnalyzer()
+            : base(
+                $"Commands must implement `{SymbolNames.CliFxCommandInterface}` interface",
+                $"This type must implement `{SymbolNames.CliFxCommandInterface}` interface in order to be a valid command.")
+        {
+        }
+
+        private void Analyze(
+            SyntaxNodeAnalysisContext context,
+            ClassDeclarationSyntax classDeclaration,
+            ITypeSymbol type)
+        {
+            var hasCommandAttribute = type
+                .GetAttributes()
+                .Select(a => a.AttributeClass)
+                .Any(s => s.DisplayNameMatches(SymbolNames.CliFxCommandAttribute));
+
+            var implementsCommandInterface = type
+                .AllInterfaces
+                .Any(s => s.DisplayNameMatches(SymbolNames.CliFxCommandInterface));
+
+            // If the attribute is present, but the interface is not implemented,
+            // it's very likely a user error.
+            if (hasCommandAttribute && !implementsCommandInterface)
+            {
+                context.ReportDiagnostic(CreateDiagnostic(classDeclaration.GetLocation()));
+            }
+        }
+
+        public override void Initialize(AnalysisContext context)
+        {
+            base.Initialize(context);
+            context.HandleClassDeclaration(Analyze);
+        }
+    }
+}

CliFx.Analyzers/ObjectModel/CommandOptionSymbol.cs

@@ -0,0 +1,83 @@
+using System.Collections.Generic;
+using Microsoft.CodeAnalysis;
+using System.Linq;
+using CliFx.Analyzers.Utils.Extensions;
+
+namespace CliFx.Analyzers.ObjectModel
+{
+    internal partial class CommandOptionSymbol
+    {
+        public string? Name { get; }
+
+        public char? ShortName { get; }
+
+        public ITypeSymbol? ConverterType { get; }
+
+        public IReadOnlyList<ITypeSymbol> ValidatorTypes { get; }
+
+        public CommandOptionSymbol(
+            string? name,
+            char? shortName,
+            ITypeSymbol? converterType,
+            IReadOnlyList<ITypeSymbol> validatorTypes)
+        {
+            Name = name;
+            ShortName = shortName;
+            ConverterType = converterType;
+            ValidatorTypes = validatorTypes;
+        }
+    }
+
+    internal partial class CommandOptionSymbol
+    {
+        private static AttributeData? TryGetOptionAttribute(IPropertySymbol property) =>
+            property
+                .GetAttributes()
+                .FirstOrDefault(a => a.AttributeClass.DisplayNameMatches(SymbolNames.CliFxCommandOptionAttribute));
+
+        private static CommandOptionSymbol FromAttribute(AttributeData attribute)
+        {
+            var name = attribute
+                .ConstructorArguments
+                .Where(a => a.Type.DisplayNameMatches("string") || a.Type.DisplayNameMatches("System.String"))
+                .Select(a => a.Value)
+                .FirstOrDefault() as string;
+
+            var shortName = attribute
+                .ConstructorArguments
+                .Where(a => a.Type.DisplayNameMatches("char") || a.Type.DisplayNameMatches("System.Char"))
+                .Select(a => a.Value)
+                .FirstOrDefault() as char?;
+
+            var converter = attribute
+                .NamedArguments
+                .Where(a => a.Key == "Converter")
+                .Select(a => a.Value.Value)
+                .Cast<ITypeSymbol?>()
+                .FirstOrDefault();
+
+            var validators = attribute
+                .NamedArguments
+                .Where(a => a.Key == "Validators")
+                .SelectMany(a => a.Value.Values)
+                .Select(c => c.Value)
+                .Cast<ITypeSymbol>()
+                .ToArray();
+
+            return new CommandOptionSymbol(name, shortName, converter, validators);
+        }
+
+        public static CommandOptionSymbol? TryResolve(IPropertySymbol property)
+        {
+            var attribute = TryGetOptionAttribute(property);
+
+            if (attribute is null)
+                return null;
+
+            return FromAttribute(attribute);
+        }
+
+        public static bool IsOptionProperty(IPropertySymbol property) =>
+            TryGetOptionAttribute(property) is not null;
+    }
+}

CliFx.Analyzers/ObjectModel/CommandParameterSymbol.cs

@@ -0,0 +1,82 @@
+using System.Collections.Generic;
+using System.Linq;
+using CliFx.Analyzers.Utils.Extensions;
+using Microsoft.CodeAnalysis;
+
+namespace CliFx.Analyzers.ObjectModel
+{
+    internal partial class CommandParameterSymbol
+    {
+        public int Order { get; }
+
+        public string? Name { get; }
+
+        public ITypeSymbol? ConverterType { get; }
+
+        public IReadOnlyList<ITypeSymbol> ValidatorTypes { get; }
+
+        public CommandParameterSymbol(
+            int order,
+            string? name,
+            ITypeSymbol? converterType,
+            IReadOnlyList<ITypeSymbol> validatorTypes)
+        {
+            Order = order;
+            Name = name;
+            ConverterType = converterType;
+            ValidatorTypes = validatorTypes;
+        }
+    }
+
+    internal partial class CommandParameterSymbol
+    {
+        private static AttributeData? TryGetParameterAttribute(IPropertySymbol property) =>
+            property
+                .GetAttributes()
+                .FirstOrDefault(a => a.AttributeClass.DisplayNameMatches(SymbolNames.CliFxCommandParameterAttribute));
+
+        private static CommandParameterSymbol FromAttribute(AttributeData attribute)
+        {
+            var order = (int) attribute
+                .ConstructorArguments
+                .Select(a => a.Value)
+                .First()!;
+
+            var name = attribute
+                .NamedArguments
+                .Where(a => a.Key == "Name")
+                .Select(a => a.Value.Value)
+                .FirstOrDefault() as string;
+
+            var converter = attribute
+                .NamedArguments
+                .Where(a => a.Key == "Converter")
+                .Select(a => a.Value.Value)
+                .Cast<ITypeSymbol?>()
+                .FirstOrDefault();
+
+            var validators = attribute
+                .NamedArguments
+                .Where(a => a.Key == "Validators")
+                .SelectMany(a => a.Value.Values)
+                .Select(c => c.Value)
+                .Cast<ITypeSymbol>()
+                .ToArray();
+
+            return new CommandParameterSymbol(order, name, converter, validators);
+        }
+
+        public static CommandParameterSymbol? TryResolve(IPropertySymbol property)
+        {
+            var attribute = TryGetParameterAttribute(property);
+
+            if (attribute is null)
+                return null;
+
+            return FromAttribute(attribute);
+        }
+
+        public static bool IsParameterProperty(IPropertySymbol property) =>
+            TryGetParameterAttribute(property) is not null;
+    }
+}

CliFx.Analyzers/ObjectModel/SymbolNames.cs

@@ -0,0 +1,15 @@
+namespace CliFx.Analyzers.ObjectModel
+{
+    internal static class SymbolNames
+    {
+        public const string CliFxCommandInterface = "CliFx.ICommand";
+        public const string CliFxCommandAttribute = "CliFx.Attributes.CommandAttribute";
+        public const string CliFxCommandParameterAttribute = "CliFx.Attributes.CommandParameterAttribute";
+        public const string CliFxCommandOptionAttribute = "CliFx.Attributes.CommandOptionAttribute";
+        public const string CliFxConsoleInterface = "CliFx.Infrastructure.IConsole";
+        public const string CliFxBindingConverterInterface = "CliFx.Extensibility.IBindingConverter";
+        public const string CliFxBindingConverterClass = "CliFx.Extensibility.BindingConverter<T>";
+        public const string CliFxBindingValidatorInterface = "CliFx.Extensibility.IBindingValidator";
+        public const string CliFxBindingValidatorClass = "CliFx.Extensibility.BindingValidator<T>";
+    }
+}

CliFx.Analyzers/OptionMustBeInsideCommandAnalyzer.cs

@@ -0,0 +1,48 @@
+using System.Linq;
+using CliFx.Analyzers.ObjectModel;
+using CliFx.Analyzers.Utils.Extensions;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace CliFx.Analyzers
+{
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public class OptionMustBeInsideCommandAnalyzer : AnalyzerBase
+    {
+        public OptionMustBeInsideCommandAnalyzer()
+            : base(
+                "Options must be defined inside commands",
+                $"This option must be defined inside a class that implements `{SymbolNames.CliFxCommandInterface}`.")
+        {
+        }
+
+        private void Analyze(
+            SyntaxNodeAnalysisContext context,
+            PropertyDeclarationSyntax propertyDeclaration,
+            IPropertySymbol property)
+        {
+            if (property.ContainingType.IsAbstract)
+                return;
+
+            if (!CommandOptionSymbol.IsOptionProperty(property))
+                return;
+
+            var isInsideCommand = property
+                .ContainingType
+                .AllInterfaces
+                .Any(s => s.DisplayNameMatches(SymbolNames.CliFxCommandInterface));
+
+            if (!isInsideCommand)
+            {
+                context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+            }
+        }
+
+        public override void Initialize(AnalysisContext context)
+        {
+            base.Initialize(context);
+            context.HandlePropertyDeclaration(Analyze);
+        }
+    }
+}

CliFx.Analyzers/OptionMustHaveNameOrShortNameAnalyzer.cs

@@ -0,0 +1,40 @@
+using CliFx.Analyzers.ObjectModel;
+using CliFx.Analyzers.Utils.Extensions;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace CliFx.Analyzers
+{
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public class OptionMustHaveNameOrShortNameAnalyzer : AnalyzerBase
+    {
+        public OptionMustHaveNameOrShortNameAnalyzer()
+            : base(
+                "Options must have either a name or short name specified",
+                "This option must have either a name or short name specified.")
+        {
+        }
+
+        private void Analyze(
+            SyntaxNodeAnalysisContext context,
+            PropertyDeclarationSyntax propertyDeclaration,
+            IPropertySymbol property)
+        {
+            var option = CommandOptionSymbol.TryResolve(property);
+            if (option is null)
+                return;
+
+            if (string.IsNullOrWhiteSpace(option.Name) && option.ShortName is null)
+            {
+                context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+            }
+        }
+
+        public override void Initialize(AnalysisContext context)
+        {
+            base.Initialize(context);
+            context.HandlePropertyDeclaration(Analyze);
+        }
+    }
+}

CliFx.Analyzers/OptionMustHaveUniqueNameAnalyzer.cs

@@ -0,0 +1,62 @@
+using System;
+using System.Linq;
+using CliFx.Analyzers.ObjectModel;
+using CliFx.Analyzers.Utils.Extensions;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace CliFx.Analyzers
+{
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public class OptionMustHaveUniqueNameAnalyzer : AnalyzerBase
+    {
+        public OptionMustHaveUniqueNameAnalyzer()
+            : base(
+                "Options must have unique names",
+                "This option's name must be unique within the command (comparison IS NOT case sensitive).")
+        {
+        }
+
+        private void Analyze(
+            SyntaxNodeAnalysisContext context,
+            PropertyDeclarationSyntax propertyDeclaration,
+            IPropertySymbol property)
+        {
+            var option = CommandOptionSymbol.TryResolve(property);
+            if (option is null)
+                return;
+
+            if (string.IsNullOrWhiteSpace(option.Name))
+                return;
+
+            var otherProperties = property
+                .ContainingType
+                .GetMembers()
+                .OfType<IPropertySymbol>()
+                .Where(m => !m.Equals(property, SymbolEqualityComparer.Default))
+                .ToArray();
+
+            foreach (var otherProperty in otherProperties)
+            {
+                var otherOption = CommandOptionSymbol.TryResolve(otherProperty);
+                if (otherOption is null)
+                    continue;
+
+                if (string.IsNullOrWhiteSpace(otherOption.Name))
+                    continue;
+
+                if (string.Equals(option.Name, otherOption.Name, StringComparison.OrdinalIgnoreCase))
+                {
+                    context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+                }
+            }
+        }
+
+        public override void Initialize(AnalysisContext context)
+        {
+            base.Initialize(context);
+            context.HandlePropertyDeclaration(Analyze);
+        }
+    }
+}

CliFx.Analyzers/OptionMustHaveUniqueShortNameAnalyzer.cs

@@ -0,0 +1,61 @@
+using System.Linq;
+using CliFx.Analyzers.ObjectModel;
+using CliFx.Analyzers.Utils.Extensions;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace CliFx.Analyzers
+{
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public class OptionMustHaveUniqueShortNameAnalyzer : AnalyzerBase
+    {
+        public OptionMustHaveUniqueShortNameAnalyzer()
+            : base(
+                "Options must have unique short names",
+                "This option's short name must be unique within the command (comparison IS case sensitive).")
+        {
+        }
+
+        private void Analyze(
+            SyntaxNodeAnalysisContext context,
+            PropertyDeclarationSyntax propertyDeclaration,
+            IPropertySymbol property)
+        {
+            var option = CommandOptionSymbol.TryResolve(property);
+            if (option is null)
+                return;
+
+            if (option.ShortName is null)
+                return;
+
+            var otherProperties = property
+                .ContainingType
+                .GetMembers()
+                .OfType<IPropertySymbol>()
+                .Where(m => !m.Equals(property, SymbolEqualityComparer.Default))
+                .ToArray();
+
+            foreach (var otherProperty in otherProperties)
+            {
+                var otherOption = CommandOptionSymbol.TryResolve(otherProperty);
+                if (otherOption is null)
+                    continue;
+
+                if (otherOption.ShortName is null)
+                    continue;
+
+                if (option.ShortName == otherOption.ShortName)
+                {
+                    context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+                }
+            }
+        }
+
+        public override void Initialize(AnalysisContext context)
+        {
+            base.Initialize(context);
+            context.HandlePropertyDeclaration(Analyze);
+        }
+    }
+}

CliFx.Analyzers/OptionMustHaveValidConverterAnalyzer.cs

@@ -0,0 +1,50 @@
+using System.Linq;
+using CliFx.Analyzers.ObjectModel;
+using CliFx.Analyzers.Utils.Extensions;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace CliFx.Analyzers
+{
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public class OptionMustHaveValidConverterAnalyzer : AnalyzerBase
+    {
+        public OptionMustHaveValidConverterAnalyzer()
+            : base(
+                $"Option converters must derive from `{SymbolNames.CliFxBindingConverterClass}`",
+                $"Converter specified for this option must derive from `{SymbolNames.CliFxBindingConverterClass}`.")
+        {
+        }
+
+        private void Analyze(
+            SyntaxNodeAnalysisContext context,
+            PropertyDeclarationSyntax propertyDeclaration,
+            IPropertySymbol property)
+        {
+            var option = CommandOptionSymbol.TryResolve(property);
+            if (option is null)
+                return;
+
+            if (option.ConverterType is null)
+                return;
+
+            // We check against an internal interface because checking against a generic class is a pain
+            var converterImplementsInterface = option
+                .ConverterType
+                .AllInterfaces
+                .Any(s => s.DisplayNameMatches(SymbolNames.CliFxBindingConverterInterface));
+
+            if (!converterImplementsInterface)
+            {
+                context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+            }
+        }
+
+        public override void Initialize(AnalysisContext context)
+        {
+            base.Initialize(context);
+            context.HandlePropertyDeclaration(Analyze);
+        }
+    }
+}

CliFx.Analyzers/OptionMustHaveValidNameAnalyzer.cs

@@ -0,0 +1,43 @@
+using CliFx.Analyzers.ObjectModel;
+using CliFx.Analyzers.Utils.Extensions;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace CliFx.Analyzers
+{
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public class OptionMustHaveValidNameAnalyzer : AnalyzerBase
+    {
+        public OptionMustHaveValidNameAnalyzer()
+            : base(
+                "Options must have valid names",
+                "This option's name must be at least 2 characters long and must start with a letter.")
+        {
+        }
+
+        private void Analyze(
+            SyntaxNodeAnalysisContext context,
+            PropertyDeclarationSyntax propertyDeclaration,
+            IPropertySymbol property)
+        {
+            var option = CommandOptionSymbol.TryResolve(property);
+            if (option is null)
+                return;
+
+            if (string.IsNullOrWhiteSpace(option.Name))
+                return;
+
+            if (option.Name.Length < 2 || !char.IsLetter(option.Name[0]))
+            {
+                context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+            }
+        }
+
+        public override void Initialize(AnalysisContext context)
+        {
+            base.Initialize(context);
+            context.HandlePropertyDeclaration(Analyze);
+        }
+    }
+}

CliFx.Analyzers/OptionMustHaveValidShortNameAnalyzer.cs

@@ -0,0 +1,43 @@
+using CliFx.Analyzers.ObjectModel;
+using CliFx.Analyzers.Utils.Extensions;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace CliFx.Analyzers
+{
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public class OptionMustHaveValidShortNameAnalyzer : AnalyzerBase
+    {
+        public OptionMustHaveValidShortNameAnalyzer()
+            : base(
+                "Option short names must be letter characters",
+                "This option's short name must be a single letter character.")
+        {
+        }
+
+        private void Analyze(
+            SyntaxNodeAnalysisContext context,
+            PropertyDeclarationSyntax propertyDeclaration,
+            IPropertySymbol property)
+        {
+            var option = CommandOptionSymbol.TryResolve(property);
+            if (option is null)
+                return;
+
+            if (option.ShortName is null)
+                return;
+
+            if (!char.IsLetter(option.ShortName.Value))
+            {
+                context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+            }
+        }
+
+        public override void Initialize(AnalysisContext context)
+        {
+            base.Initialize(context);
+            context.HandlePropertyDeclaration(Analyze);
+        }
+    }
+}

CliFx.Analyzers/OptionMustHaveValidValidatorsAnalyzer.cs

@@ -0,0 +1,52 @@
+using System.Linq;
+using CliFx.Analyzers.ObjectModel;
+using CliFx.Analyzers.Utils.Extensions;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace CliFx.Analyzers
+{
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public class OptionMustHaveValidValidatorsAnalyzer : AnalyzerBase
+    {
+        public OptionMustHaveValidValidatorsAnalyzer()
+            : base(
+                $"Option validators must derive from `{SymbolNames.CliFxBindingValidatorClass}`",
+                $"All validators specified for this option must derive from `{SymbolNames.CliFxBindingValidatorClass}`.")
+        {
+        }
+
+        private void Analyze(
+            SyntaxNodeAnalysisContext context,
+            PropertyDeclarationSyntax propertyDeclaration,
+            IPropertySymbol property)
+        {
+            var option = CommandOptionSymbol.TryResolve(property);
+            if (option is null)
+                return;
+
+            foreach (var validatorType in option.ValidatorTypes)
+            {
+                // We check against an internal interface because checking against a generic class is a pain
+                var validatorImplementsInterface = validatorType
+                    .AllInterfaces
+                    .Any(s => s.DisplayNameMatches(SymbolNames.CliFxBindingValidatorInterface));
+
+                if (!validatorImplementsInterface)
+                {
+                    context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+
+                    // No need to report multiple identical diagnostics on the same node
+                    break;
+                }
+            }
+        }
+
+        public override void Initialize(AnalysisContext context)
+        {
+            base.Initialize(context);
+            context.HandlePropertyDeclaration(Analyze);
+        }
+    }
+}

CliFx.Analyzers/ParameterMustBeInsideCommandAnalyzer.cs

@@ -0,0 +1,48 @@
+using System.Linq;
+using CliFx.Analyzers.ObjectModel;
+using CliFx.Analyzers.Utils.Extensions;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace CliFx.Analyzers
+{
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public class ParameterMustBeInsideCommandAnalyzer : AnalyzerBase
+    {
+        public ParameterMustBeInsideCommandAnalyzer()
+            : base(
+                "Parameters must be defined inside commands",
+                $"This parameter must be defined inside a class that implements `{SymbolNames.CliFxCommandInterface}`.")
+        {
+        }
+
+        private void Analyze(
+            SyntaxNodeAnalysisContext context,
+            PropertyDeclarationSyntax propertyDeclaration,
+            IPropertySymbol property)
+        {
+            if (property.ContainingType.IsAbstract)
+                return;
+
+            if (!CommandParameterSymbol.IsParameterProperty(property))
+                return;
+
+            var isInsideCommand = property
+                .ContainingType
+                .AllInterfaces
+                .Any(s => s.DisplayNameMatches(SymbolNames.CliFxCommandInterface));
+
+            if (!isInsideCommand)
+            {
+                context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+            }
+        }
+
+        public override void Initialize(AnalysisContext context)
+        {
+            base.Initialize(context);
+            context.HandlePropertyDeclaration(Analyze);
+        }
+    }
+}

CliFx.Analyzers/ParameterMustBeLastIfNonScalarAnalyzer.cs

@@ -0,0 +1,65 @@
+using System.Linq;
+using CliFx.Analyzers.ObjectModel;
+using CliFx.Analyzers.Utils.Extensions;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace CliFx.Analyzers
+{
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public class ParameterMustBeLastIfNonScalarAnalyzer : AnalyzerBase
+    {
+        public ParameterMustBeLastIfNonScalarAnalyzer()
+            : base(
+                "Parameters of non-scalar types must be last in order",
+                "This parameter has a non-scalar type so it must be last in order (its order must be highest within the command).")
+        {
+        }
+
+        private static bool IsScalar(ITypeSymbol type) =>
+            type.DisplayNameMatches("string") ||
+            type.DisplayNameMatches("System.String") ||
+            !type.AllInterfaces
+                .Select(i => i.ConstructedFrom)
+                .Any(s => s.DisplayNameMatches("System.Collections.Generic.IEnumerable<T>"));
+
+        private void Analyze(
+            SyntaxNodeAnalysisContext context,
+            PropertyDeclarationSyntax propertyDeclaration,
+            IPropertySymbol property)
+        {
+            if (IsScalar(property.Type))
+                return;
+
+            var parameter = CommandParameterSymbol.TryResolve(property);
+            if (parameter is null)
+                return;
+
+            var otherProperties = property
+                .ContainingType
+                .GetMembers()
+                .OfType<IPropertySymbol>()
+                .Where(m => !m.Equals(property, SymbolEqualityComparer.Default))
+                .ToArray();
+
+            foreach (var otherProperty in otherProperties)
+            {
+                var otherParameter = CommandParameterSymbol.TryResolve(otherProperty);
+                if (otherParameter is null)
+                    continue;
+
+                if (otherParameter.Order > parameter.Order)
+                {
+                    context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+                }
+            }
+        }
+
+        public override void Initialize(AnalysisContext context)
+        {
+            base.Initialize(context);
+            context.HandlePropertyDeclaration(Analyze);
+        }
+    }
+}

CliFx.Analyzers/ParameterMustBeSingleIfNonScalarAnalyzer.cs

@@ -0,0 +1,63 @@
+using System.Linq;
+using CliFx.Analyzers.ObjectModel;
+using CliFx.Analyzers.Utils.Extensions;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace CliFx.Analyzers
+{
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public class ParameterMustBeSingleIfNonScalarAnalyzer : AnalyzerBase
+    {
+        public ParameterMustBeSingleIfNonScalarAnalyzer()
+            : base(
+                "Parameters of non-scalar types are limited to one per command",
+                "This parameter has a non-scalar type so it must be the only such parameter in the command.")
+        {
+        }
+
+        private static bool IsScalar(ITypeSymbol type) =>
+            type.DisplayNameMatches("string") ||
+            type.DisplayNameMatches("System.String") ||
+            !type.AllInterfaces
+                .Select(i => i.ConstructedFrom)
+                .Any(s => s.DisplayNameMatches("System.Collections.Generic.IEnumerable<T>"));
+
+        private void Analyze(
+            SyntaxNodeAnalysisContext context,
+            PropertyDeclarationSyntax propertyDeclaration,
+            IPropertySymbol property)
+        {
+            if (!CommandParameterSymbol.IsParameterProperty(property))
+                return;
+
+            if (IsScalar(property.Type))
+                return;
+
+            var otherProperties = property
+                .ContainingType
+                .GetMembers()
+                .OfType<IPropertySymbol>()
+                .Where(m => !m.Equals(property, SymbolEqualityComparer.Default))
+                .ToArray();
+
+            foreach (var otherProperty in otherProperties)
+            {
+                if (!CommandParameterSymbol.IsParameterProperty(otherProperty))
+                    continue;
+
+                if (!IsScalar(otherProperty.Type))
+                {
+                    context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+                }
+            }
+        }
+
+        public override void Initialize(AnalysisContext context)
+        {
+            base.Initialize(context);
+            context.HandlePropertyDeclaration(Analyze);
+        }
+    }
+}

CliFx.Analyzers/ParameterMustHaveUniqueNameAnalyzer.cs

@@ -0,0 +1,62 @@
+using System;
+using System.Linq;
+using CliFx.Analyzers.ObjectModel;
+using CliFx.Analyzers.Utils.Extensions;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace CliFx.Analyzers
+{
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public class ParameterMustHaveUniqueNameAnalyzer : AnalyzerBase
+    {
+        public ParameterMustHaveUniqueNameAnalyzer()
+            : base(
+                "Parameters must have unique names",
+                "This parameter's name must be unique within the command (comparison IS NOT case sensitive).")
+        {
+        }
+
+        private void Analyze(
+            SyntaxNodeAnalysisContext context,
+            PropertyDeclarationSyntax propertyDeclaration,
+            IPropertySymbol property)
+        {
+            var parameter = CommandParameterSymbol.TryResolve(property);
+            if (parameter is null)
+                return;
+
+            if (string.IsNullOrWhiteSpace(parameter.Name))
+                return;
+
+            var otherProperties = property
+                .ContainingType
+                .GetMembers()
+                .OfType<IPropertySymbol>()
+                .Where(m => !m.Equals(property, SymbolEqualityComparer.Default))
+                .ToArray();
+
+            foreach (var otherProperty in otherProperties)
+            {
+                var otherParameter = CommandParameterSymbol.TryResolve(otherProperty);
+                if (otherParameter is null)
+                    continue;
+
+                if (string.IsNullOrWhiteSpace(otherParameter.Name))
+                    continue;
+
+                if (string.Equals(parameter.Name, otherParameter.Name, StringComparison.OrdinalIgnoreCase))
+                {
+                    context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+                }
+            }
+        }
+
+        public override void Initialize(AnalysisContext context)
+        {
+            base.Initialize(context);
+            context.HandlePropertyDeclaration(Analyze);
+        }
+    }
+}

CliFx.Analyzers/ParameterMustHaveUniqueOrderAnalyzer.cs

@@ -0,0 +1,55 @@
+using System.Linq;
+using CliFx.Analyzers.ObjectModel;
+using CliFx.Analyzers.Utils.Extensions;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace CliFx.Analyzers
+{
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public class ParameterMustHaveUniqueOrderAnalyzer : AnalyzerBase
+    {
+        public ParameterMustHaveUniqueOrderAnalyzer()
+            : base(
+                "Parameters must have unique order",
+                "This parameter's order must be unique within the command.")
+        {
+        }
+
+        private void Analyze(
+            SyntaxNodeAnalysisContext context,
+            PropertyDeclarationSyntax propertyDeclaration,
+            IPropertySymbol property)
+        {
+            var parameter = CommandParameterSymbol.TryResolve(property);
+            if (parameter is null)
+                return;
+
+            var otherProperties = property
+                .ContainingType
+                .GetMembers()
+                .OfType<IPropertySymbol>()
+                .Where(m => !m.Equals(property, SymbolEqualityComparer.Default))
+                .ToArray();
+
+            foreach (var otherProperty in otherProperties)
+            {
+                var otherParameter = CommandParameterSymbol.TryResolve(otherProperty);
+                if (otherParameter is null)
+                    continue;
+
+                if (parameter.Order == otherParameter.Order)
+                {
+                    context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+                }
+            }
+        }
+
+        public override void Initialize(AnalysisContext context)
+        {
+            base.Initialize(context);
+            context.HandlePropertyDeclaration(Analyze);
+        }
+    }
+}

CliFx.Analyzers/ParameterMustHaveValidConverterAnalyzer.cs

@@ -0,0 +1,50 @@
+using System.Linq;
+using CliFx.Analyzers.ObjectModel;
+using CliFx.Analyzers.Utils.Extensions;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace CliFx.Analyzers
+{
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public class ParameterMustHaveValidConverterAnalyzer : AnalyzerBase
+    {
+        public ParameterMustHaveValidConverterAnalyzer()
+            : base(
+                $"Parameter converters must derive from `{SymbolNames.CliFxBindingConverterClass}`",
+                $"Converter specified for this parameter must derive from `{SymbolNames.CliFxBindingConverterClass}`.")
+        {
+        }
+
+        private void Analyze(
+            SyntaxNodeAnalysisContext context,
+            PropertyDeclarationSyntax propertyDeclaration,
+            IPropertySymbol property)
+        {
+            var parameter = CommandParameterSymbol.TryResolve(property);
+            if (parameter is null)
+                return;
+
+            if (parameter.ConverterType is null)
+                return;
+
+            // We check against an internal interface because checking against a generic class is a pain
+            var converterImplementsInterface = parameter
+                .ConverterType
+                .AllInterfaces
+                .Any(s => s.DisplayNameMatches(SymbolNames.CliFxBindingConverterInterface));
+
+            if (!converterImplementsInterface)
+            {
+                context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+            }
+        }
+
+        public override void Initialize(AnalysisContext context)
+        {
+            base.Initialize(context);
+            context.HandlePropertyDeclaration(Analyze);
+        }
+    }
+}

CliFx.Analyzers/ParameterMustHaveValidValidatorsAnalyzer.cs

@@ -0,0 +1,52 @@
+using System.Linq;
+using CliFx.Analyzers.ObjectModel;
+using CliFx.Analyzers.Utils.Extensions;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace CliFx.Analyzers
+{
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public class ParameterMustHaveValidValidatorsAnalyzer : AnalyzerBase
+    {
+        public ParameterMustHaveValidValidatorsAnalyzer()
+            : base(
+                $"Parameter validators must derive from `{SymbolNames.CliFxBindingValidatorClass}`",
+                $"All validators specified for this parameter must derive from `{SymbolNames.CliFxBindingValidatorClass}`.")
+        {
+        }
+
+        private void Analyze(
+            SyntaxNodeAnalysisContext context,
+            PropertyDeclarationSyntax propertyDeclaration,
+            IPropertySymbol property)
+        {
+            var parameter = CommandParameterSymbol.TryResolve(property);
+            if (parameter is null)
+                return;
+
+            foreach (var validatorType in parameter.ValidatorTypes)
+            {
+                // We check against an internal interface because checking against a generic class is a pain
+                var validatorImplementsInterface = validatorType
+                    .AllInterfaces
+                    .Any(s => s.DisplayNameMatches(SymbolNames.CliFxBindingValidatorInterface));
+
+                if (!validatorImplementsInterface)
+                {
+                    context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+
+                    // No need to report multiple identical diagnostics on the same node
+                    break;
+                }
+            }
+        }
+
+        public override void Initialize(AnalysisContext context)
+        {
+            base.Initialize(context);
+            context.HandlePropertyDeclaration(Analyze);
+        }
+    }
+}

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);
+        }
+    }
+}

CliFx.Analyzers/Utils/Extensions/RoslynExtensions.cs

@@ -0,0 +1,48 @@
+using System;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace CliFx.Analyzers.Utils.Extensions
+{
+    internal static class RoslynExtensions
+    {
+        public static bool DisplayNameMatches(this ISymbol symbol, string name) =>
+            string.Equals(symbol.ToDisplayString(), name, StringComparison.Ordinal);
+
+        public static void HandleClassDeclaration(
+            this AnalysisContext analysisContext,
+            Action<SyntaxNodeAnalysisContext, ClassDeclarationSyntax, ITypeSymbol> handler)
+        {
+            analysisContext.RegisterSyntaxNodeAction(ctx =>
+            {
+                if (ctx.Node is not ClassDeclarationSyntax classDeclaration)
+                    return;
+
+                var type = ctx.SemanticModel.GetDeclaredSymbol(classDeclaration);
+                if (type is null)
+                    return;
+
+                handler(ctx, classDeclaration, type);
+            }, SyntaxKind.ClassDeclaration);
+        }
+
+        public static void HandlePropertyDeclaration(
+            this AnalysisContext analysisContext,
+            Action<SyntaxNodeAnalysisContext, PropertyDeclarationSyntax, IPropertySymbol> handler)
+        {
+            analysisContext.RegisterSyntaxNodeAction(ctx =>
+            {
+                if (ctx.Node is not PropertyDeclarationSyntax propertyDeclaration)
+                    return;
+
+                var property = ctx.SemanticModel.GetDeclaredSymbol(propertyDeclaration);
+                if (property is null)
+                    return;
+
+                handler(ctx, propertyDeclaration, property);
+            }, SyntaxKind.PropertyDeclaration);
+        }
+    }
+}

CliFx.Analyzers/Utils/Extensions/StringExtensions.cs

@@ -0,0 +1,18 @@
+using System;
+
+namespace CliFx.Analyzers.Utils.Extensions
+{
+    internal static class StringExtensions
+    {
+        public static string TrimEnd(
+            this string str,
+            string sub,
+            StringComparison comparison = StringComparison.Ordinal)
+        {
+            while (str.EndsWith(sub, comparison))
+                str = str.Substring(0, str.Length - sub.Length);
+
+            return str;
+        }
+    }
+}

CliFx.Benchmarks/Benchmark.cs

@@ -1,46 +0,0 @@
-using System.Threading.Tasks;
-using BenchmarkDotNet.Attributes;
-using BenchmarkDotNet.Order;
-using CliFx.Benchmarks.Commands;
-using CommandLine;
-
-namespace CliFx.Benchmarks
-{
-    [SimpleJob]
-    [RankColumn]
-    [Orderer(SummaryOrderPolicy.FastestToSlowest)]
-    public class Benchmark
-    {
-        private static readonly string[] Arguments = {"--str", "hello world", "-i", "13", "-b"};
-
-        [Benchmark(Description = "CliFx", Baseline = true)]
-        public async ValueTask<int> ExecuteWithCliFx() =>
-            await new CliApplicationBuilder().AddCommand(typeof(CliFxCommand)).Build().RunAsync(Arguments);
-
-        [Benchmark(Description = "System.CommandLine")]
-        public async Task<int> ExecuteWithSystemCommandLine() =>
-            await new SystemCommandLineCommand().ExecuteAsync(Arguments);
-
-        [Benchmark(Description = "McMaster.Extensions.CommandLineUtils")]
-        public int ExecuteWithMcMaster() =>
-            McMaster.Extensions.CommandLineUtils.CommandLineApplication.Execute<McMasterCommand>(Arguments);
-
-        [Benchmark(Description = "CommandLineParser")]
-        public void ExecuteWithCommandLineParser() =>
-            new Parser()
-                .ParseArguments(Arguments, typeof(CommandLineParserCommand))
-                .WithParsed<CommandLineParserCommand>(c => c.Execute());
-
-        [Benchmark(Description = "PowerArgs")]
-        public void ExecuteWithPowerArgs() =>
-            PowerArgs.Args.InvokeMain<PowerArgsCommand>(Arguments);
-
-        [Benchmark(Description = "Clipr")]
-        public void ExecuteWithClipr() =>
-            clipr.CliParser.Parse<CliprCommand>(Arguments).Execute();
-
-        [Benchmark(Description = "Cocona")]
-        public void ExecuteWithCocona() =>
-            Cocona.CoconaApp.Run<CoconaCommand>(Arguments);
-    }
-}

CliFx.Benchmarks/Benchmarks.CliFx.cs

@@ -0,0 +1,33 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using BenchmarkDotNet.Attributes;
+using CliFx.Attributes;
+using CliFx.Infrastructure;
+
+namespace CliFx.Benchmarks
+{
+    public partial class Benchmarks
+    {
+        [Command]
+        public class CliFxCommand : ICommand
+        {
+            [CommandOption("str", 's')]
+            public string? StrOption { get; set; }
+
+            [CommandOption("int", 'i')]
+            public int IntOption { get; set; }
+
+            [CommandOption("bool", 'b')]
+            public bool BoolOption { get; set; }
+
+            public ValueTask ExecuteAsync(IConsole console) => default;
+        }
+
+        [Benchmark(Description = "CliFx", Baseline = true)]
+        public async ValueTask<int> ExecuteWithCliFx() =>
+            await new CliApplicationBuilder()
+                .AddCommand<CliFxCommand>()
+                .Build()
+                .RunAsync(Arguments, new Dictionary<string, string>());
+    }
+}

CliFx.Benchmarks/Benchmarks.Clipr.cs

@@ -0,0 +1,27 @@
+using BenchmarkDotNet.Attributes;
+using clipr;
+
+namespace CliFx.Benchmarks
+{
+    public partial class Benchmarks
+    {
+        public class CliprCommand
+        {
+            [NamedArgument('s', "str")]
+            public string? StrOption { get; set; }
+
+            [NamedArgument('i', "int")]
+            public int IntOption { get; set; }
+
+            [NamedArgument('b', "bool", Constraint = NumArgsConstraint.Optional, Const = true)]
+            public bool BoolOption { get; set; }
+
+            public void Execute()
+            {
+            }
+        }
+
+        [Benchmark(Description = "Clipr")]
+        public void ExecuteWithClipr() => CliParser.Parse<CliprCommand>(Arguments).Execute();
+    }
+}

CliFx.Benchmarks/Benchmarks.Cocona.cs

@@ -0,0 +1,24 @@
+using BenchmarkDotNet.Attributes;
+using Cocona;
+
+namespace CliFx.Benchmarks
+{
+    public partial class Benchmarks
+    {
+        public class CoconaCommand
+        {
+            public void Execute(
+                [Option("str", new []{'s'})]
+                string? strOption,
+                [Option("int", new []{'i'})]
+                int intOption,
+                [Option("bool", new []{'b'})]
+                bool boolOption)
+            {
+            }
+        }
+
+        [Benchmark(Description = "Cocona")]
+        public void ExecuteWithCocona() => CoconaApp.Run<CoconaCommand>(Arguments);
+    }
+}

CliFx.Benchmarks/Benchmarks.CommandLineParser.cs

@@ -0,0 +1,30 @@
+using BenchmarkDotNet.Attributes;
+using CommandLine;
+
+namespace CliFx.Benchmarks
+{
+    public partial class Benchmarks
+    {
+        public class CommandLineParserCommand
+        {
+            [Option('s', "str")]
+            public string? StrOption { get; set; }
+
+            [Option('i', "int")]
+            public int IntOption { get; set; }
+
+            [Option('b', "bool")]
+            public bool BoolOption { get; set; }
+
+            public void Execute()
+            {
+            }
+        }
+
+        [Benchmark(Description = "CommandLineParser")]
+        public void ExecuteWithCommandLineParser() =>
+            new Parser()
+                .ParseArguments(Arguments, typeof(CommandLineParserCommand))
+                .WithParsed<CommandLineParserCommand>(c => c.Execute());
+    }
+}

CliFx.Benchmarks/Benchmarks.McMaster.cs

@@ -0,0 +1,25 @@
+using BenchmarkDotNet.Attributes;
+using McMaster.Extensions.CommandLineUtils;
+
+namespace CliFx.Benchmarks
+{
+    public partial class Benchmarks
+    {
+        public class McMasterCommand
+        {
+            [Option("--str|-s")]
+            public string? StrOption { get; set; }
+
+            [Option("--int|-i")]
+            public int IntOption { get; set; }
+
+            [Option("--bool|-b")]
+            public bool BoolOption { get; set; }
+
+            public int OnExecute() => 0;
+        }
+
+        [Benchmark(Description = "McMaster.Extensions.CommandLineUtils")]
+        public int ExecuteWithMcMaster() => CommandLineApplication.Execute<McMasterCommand>(Arguments);
+    }
+}

CliFx.Benchmarks/Benchmarks.PowerArgs.cs

@@ -0,0 +1,27 @@
+using BenchmarkDotNet.Attributes;
+using PowerArgs;
+
+namespace CliFx.Benchmarks
+{
+    public partial class Benchmarks
+    {
+        public class PowerArgsCommand
+        {
+            [ArgShortcut("--str"), ArgShortcut("-s")]
+            public string? StrOption { get; set; }
+
+            [ArgShortcut("--int"), ArgShortcut("-i")]
+            public int IntOption { get; set; }
+
+            [ArgShortcut("--bool"), ArgShortcut("-b")]
+            public bool BoolOption { get; set; }
+
+            public void Main()
+            {
+            }
+        }
+
+        [Benchmark(Description = "PowerArgs")]
+        public void ExecuteWithPowerArgs() => Args.InvokeMain<PowerArgsCommand>(Arguments);
+    }
+}

CliFx.Benchmarks/Benchmarks.SystemCommandLine.cs

@@ -0,0 +1,44 @@
+using System.CommandLine;
+using System.CommandLine.Invocation;
+using System.Threading.Tasks;
+using BenchmarkDotNet.Attributes;
+
+namespace CliFx.Benchmarks
+{
+    public partial class Benchmarks
+    {
+        public class SystemCommandLineCommand
+        {
+            public static int ExecuteHandler(string s, int i, bool b) => 0;
+
+            public Task<int> ExecuteAsync(string[] args)
+            {
+                var command = new RootCommand
+                {
+                    new Option(new[] {"--str", "-s"})
+                    {
+                        Argument = new Argument<string?>()
+                    },
+                    new Option(new[] {"--int", "-i"})
+                    {
+                        Argument = new Argument<int>()
+                    },
+                    new Option(new[] {"--bool", "-b"})
+                    {
+                        Argument = new Argument<bool>()
+                    }
+                };
+
+                command.Handler = CommandHandler.Create(
+                    typeof(SystemCommandLineCommand).GetMethod(nameof(ExecuteHandler))!
+                );
+
+                return command.InvokeAsync(args);
+            }
+        }
+
+        [Benchmark(Description = "System.CommandLine")]
+        public async Task<int> ExecuteWithSystemCommandLine() =>
+            await new SystemCommandLineCommand().ExecuteAsync(Arguments);
+    }
+}

CliFx.Benchmarks/Benchmarks.cs

@@ -0,0 +1,20 @@
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Configs;
+using BenchmarkDotNet.Order;
+using BenchmarkDotNet.Running;
+
+namespace CliFx.Benchmarks
+{
+    [RankColumn]
+    [Orderer(SummaryOrderPolicy.FastestToSlowest)]
+    public partial class Benchmarks
+    {
+        private static readonly string[] Arguments = {"--str", "hello world", "-i", "13", "-b"};
+
+        public static void Main() => BenchmarkRunner.Run<Benchmarks>(
+            DefaultConfig
+                .Instance
+                .With(ConfigOptions.DisableOptimizationsValidator)
+        );
+    }
+}

CliFx.Benchmarks/CliFx.Benchmarks.csproj

@@ -1,19 +1,18 @@
 <Project Sdk="Microsoft.NET.Sdk">
-  <Import Project="../CliFx.props" />
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <TargetFramework>net5.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
     <PackageReference Include="BenchmarkDotNet" Version="0.12.0" />
     <PackageReference Include="clipr" Version="1.6.1" />
-    <PackageReference Include="Cocona" Version="1.0.0" />
-    <PackageReference Include="CommandLineParser" Version="2.7.82" />
-    <PackageReference Include="McMaster.Extensions.CommandLineUtils" Version="2.5.0" />
+    <PackageReference Include="Cocona" Version="1.5.0" />
+    <PackageReference Include="CommandLineParser" Version="2.8.0" />
+    <PackageReference Include="McMaster.Extensions.CommandLineUtils" Version="3.1.0" />
     <PackageReference Include="PowerArgs" Version="3.6.0" />
-    <PackageReference Include="System.CommandLine.Experimental" Version="0.3.0-alpha.19317.1" />
+    <PackageReference Include="System.CommandLine" Version="2.0.0-beta1.20574.7" />
   </ItemGroup>
 
   <ItemGroup>

CliFx.Benchmarks/Commands/CliFxCommand.cs

@@ -1,20 +0,0 @@
-using System.Threading.Tasks;
-using CliFx.Attributes;
-
-namespace CliFx.Benchmarks.Commands
-{
-    [Command]
-    public class CliFxCommand : ICommand
-    {
-        [CommandOption("str", 's')]
-        public string? StrOption { get; set; }
-
-        [CommandOption("int", 'i')]
-        public int IntOption { get; set; }
-
-        [CommandOption("bool", 'b')]
-        public bool BoolOption { get; set; }
-
-        public ValueTask ExecuteAsync(IConsole console) => default;
-    }
-}

CliFx.Benchmarks/Commands/CliprCommand.cs

@@ -1,20 +0,0 @@
-using clipr;
-
-namespace CliFx.Benchmarks.Commands
-{
-    public class CliprCommand
-    {
-        [NamedArgument('s', "str")]
-        public string? StrOption { get; set; }
-
-        [NamedArgument('i', "int")]
-        public int IntOption { get; set; }
-
-        [NamedArgument('b', "bool", Constraint = NumArgsConstraint.Optional, Const = true)]
-        public bool BoolOption { get; set; }
-
-        public void Execute()
-        {
-        }
-    }
-}

CliFx.Benchmarks/Commands/CoconaCommand.cs

@@ -1,17 +0,0 @@
-using Cocona;
-
-namespace CliFx.Benchmarks.Commands
-{
-    public class CoconaCommand
-    {
-        public void Execute(
-            [Option("str", new []{'s'})]
-            string? strOption,
-            [Option("int", new []{'i'})]
-            int intOption,
-            [Option("bool", new []{'b'})]
-            bool boolOption)
-        {
-        }
-    }
-}

CliFx.Benchmarks/Commands/CommandLineParserCommand.cs

@@ -1,20 +0,0 @@
-using CommandLine;
-
-namespace CliFx.Benchmarks.Commands
-{
-    public class CommandLineParserCommand
-    {
-        [Option('s', "str")]
-        public string? StrOption { get; set; }
-
-        [Option('i', "int")]
-        public int IntOption { get; set; }
-
-        [Option('b', "bool")]
-        public bool BoolOption { get; set; }
-
-        public void Execute()
-        {
-        }
-    }
-}

CliFx.Benchmarks/Commands/McMasterCommand.cs

@@ -1,18 +0,0 @@
-using McMaster.Extensions.CommandLineUtils;
-
-namespace CliFx.Benchmarks.Commands
-{
-    public class McMasterCommand
-    {
-        [Option("--str|-s")]
-        public string? StrOption { get; set; }
-
-        [Option("--int|-i")]
-        public int IntOption { get; set; }
-
-        [Option("--bool|-b")]
-        public bool BoolOption { get; set; }
-
-        public int OnExecute() => 0;
-    }
-}

CliFx.Benchmarks/Commands/PowerArgsCommand.cs

@@ -1,20 +0,0 @@
-using PowerArgs;
-
-namespace CliFx.Benchmarks.Commands
-{
-    public class PowerArgsCommand
-    {
-        [ArgShortcut("--str"), ArgShortcut("-s")]
-        public string? StrOption { get; set; }
-
-        [ArgShortcut("--int"), ArgShortcut("-i")]
-        public int IntOption { get; set; }
-
-        [ArgShortcut("--bool"), ArgShortcut("-b")]
-        public bool BoolOption { get; set; }
-
-        public void Main()
-        {
-        }
-    }
-}

CliFx.Benchmarks/Commands/SystemCommandLineCommand.cs

@@ -1,34 +0,0 @@
-using System.CommandLine;
-using System.CommandLine.Invocation;
-using System.Threading.Tasks;
-
-namespace CliFx.Benchmarks.Commands
-{
-    public class SystemCommandLineCommand
-    {
-        public static int ExecuteHandler(string s, int i, bool b) => 0;
-
-        public Task<int> ExecuteAsync(string[] args)
-        {
-            var command = new RootCommand
-            {
-                new Option(new[] {"--str", "-s"})
-                {
-                    Argument = new Argument<string?>()
-                },
-                new Option(new[] {"--int", "-i"})
-                {
-                    Argument = new Argument<int>()
-                },
-                new Option(new[] {"--bool", "-b"})
-                {
-                    Argument = new Argument<bool>()
-                }
-            };
-
-            command.Handler = CommandHandler.Create(typeof(SystemCommandLineCommand).GetMethod(nameof(ExecuteHandler)));
-
-            return command.InvokeAsync(args);
-        }
-    }
-}

CliFx.Benchmarks/Program.cs

@@ -1,12 +0,0 @@
-using BenchmarkDotNet.Configs;
-using BenchmarkDotNet.Running;
-
-namespace CliFx.Benchmarks
-{
-    public static class Program
-    {
-        public static void Main() =>
-            BenchmarkRunner.Run(typeof(Program).Assembly, DefaultConfig.Instance
-                .With(ConfigOptions.DisableOptimizationsValidator));
-    }
-}

CliFx.Benchmarks/Readme.md

@@ -0,0 +1,22 @@
+## CliFx.Benchmarks
+
+All benchmarks below were ran with the following configuration:
+
+```ini
+BenchmarkDotNet=v0.12.0, OS=Windows 10.0.14393.3443 (1607/AnniversaryUpdate/Redstone1)
+Intel Core i5-4460 CPU 3.20GHz (Haswell), 1 CPU, 4 logical and 4 physical cores
+Frequency=3124994 Hz, Resolution=320.0006 ns, Timer=TSC
+.NET Core SDK=3.1.100
+  [Host]     : .NET Core 3.1.0 (CoreCLR 4.700.19.56402, CoreFX 4.700.19.56404), X64 RyuJIT
+  DefaultJob : .NET Core 3.1.0 (CoreCLR 4.700.19.56402, CoreFX 4.700.19.56404), X64 RyuJIT
+```
+
+| Method                               |        Mean |     Error |     StdDev | Ratio | RatioSD | Rank |
+| ------------------------------------ | ----------: | --------: | ---------: | ----: | ------: | ---: |
+| CommandLineParser                    |    24.79 us |  0.166 us |   0.155 us |  0.49 |    0.00 |    1 |
+| CliFx                                |    50.27 us |  0.248 us |   0.232 us |  1.00 |    0.00 |    2 |
+| Clipr                                |   160.22 us |  0.817 us |   0.764 us |  3.19 |    0.02 |    3 |
+| McMaster.Extensions.CommandLineUtils |   166.45 us |  1.111 us |   1.039 us |  3.31 |    0.03 |    4 |
+| System.CommandLine                   |   170.27 us |  0.599 us |   0.560 us |  3.39 |    0.02 |    5 |
+| PowerArgs                            |   306.12 us |  1.495 us |   1.398 us |  6.09 |    0.03 |    6 |
+| Cocona                               | 1,856.07 us | 48.727 us | 141.367 us | 37.88 |    2.60 |    7 |

CliFx.Demo/CliFx.Demo.csproj

@@ -1,18 +1,18 @@
 <Project Sdk="Microsoft.NET.Sdk">
-  <Import Project="../CliFx.props" />
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <TargetFramework>net5.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="3.1.1" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="5.0.1" />
     <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
   </ItemGroup>
 
   <ItemGroup>
     <ProjectReference Include="..\CliFx\CliFx.csproj" />
+    <ProjectReference Include="..\CliFx.Analyzers\CliFx.Analyzers.csproj" ReferenceOutputAssembly="false" OutputItemType="Analyzer" />
   </ItemGroup>
 
 </Project>

CliFx.Demo/Commands/BookAddCommand.cs

@@ -1,45 +1,45 @@
 using System;
 using System.Threading.Tasks;
 using CliFx.Attributes;
-using CliFx.Demo.Internal;
-using CliFx.Demo.Models;
-using CliFx.Demo.Services;
+using CliFx.Demo.Domain;
+using CliFx.Demo.Utils;
 using CliFx.Exceptions;
+using CliFx.Infrastructure;
 
 namespace CliFx.Demo.Commands
 {
     [Command("book add", Description = "Add a book to the library.")]
     public partial class BookAddCommand : ICommand
     {
-        private readonly LibraryService _libraryService;
+        private readonly LibraryProvider _libraryProvider;
 
         [CommandParameter(0, Name = "title", Description = "Book title.")]
-        public string Title { get; set; } = "";
+        public string Title { get; init; } = "";
 
         [CommandOption("author", 'a', IsRequired = true, Description = "Book author.")]
-        public string Author { get; set; } = "";
+        public string Author { get; init; } = "";
 
         [CommandOption("published", 'p', Description = "Book publish date.")]
-        public DateTimeOffset Published { get; set; } = CreateRandomDate();
+        public DateTimeOffset Published { get; init; } = CreateRandomDate();
 
         [CommandOption("isbn", 'n', Description = "Book ISBN.")]
-        public Isbn Isbn { get; set; } = CreateRandomIsbn();
+        public Isbn Isbn { get; init; } = CreateRandomIsbn();
 
-        public BookAddCommand(LibraryService libraryService)
+        public BookAddCommand(LibraryProvider libraryProvider)
         {
-            _libraryService = libraryService;
+            _libraryProvider = libraryProvider;
         }
 
         public ValueTask ExecuteAsync(IConsole console)
         {
-            if (_libraryService.GetBook(Title) != null)
-                throw new CommandException("Book already exists.", 1);
+            if (_libraryProvider.TryGetBook(Title) is not null)
+                throw new CommandException("Book already exists.", 10);
 
             var book = new Book(Title, Author, Published, Isbn);
-            _libraryService.AddBook(book);
+            _libraryProvider.AddBook(book);
 
             console.Output.WriteLine("Book added.");
-            console.RenderBook(book);
+            console.Output.WriteBook(book);
 
             return default;
         }
@@ -47,22 +47,24 @@ namespace CliFx.Demo.Commands
 
     public partial class BookAddCommand
     {
-        private static readonly Random Random = new Random();
+        private static readonly Random Random = new();
 
-        private static DateTimeOffset CreateRandomDate() => new DateTimeOffset(
+        private static DateTimeOffset CreateRandomDate() => new(
             Random.Next(1800, 2020),
             Random.Next(1, 12),
             Random.Next(1, 28),
             Random.Next(1, 23),
             Random.Next(1, 59),
             Random.Next(1, 59),
-            TimeSpan.Zero);
+            TimeSpan.Zero
+        );
 
-        private static Isbn CreateRandomIsbn() => new Isbn(
+        private static Isbn CreateRandomIsbn() => new(
             Random.Next(0, 999),
             Random.Next(0, 99),
             Random.Next(0, 99999),
             Random.Next(0, 99),
-            Random.Next(0, 9));
+            Random.Next(0, 9)
+        );
     }
 }

CliFx.Demo/Commands/BookCommand.cs

@@ -1,32 +1,33 @@
 using System.Threading.Tasks;
 using CliFx.Attributes;
-using CliFx.Demo.Internal;
-using CliFx.Demo.Services;
+using CliFx.Demo.Domain;
+using CliFx.Demo.Utils;
 using CliFx.Exceptions;
+using CliFx.Infrastructure;
 
 namespace CliFx.Demo.Commands
 {
-    [Command("book", Description = "View, list, add or remove books.")]
+    [Command("book", Description = "Retrieve a book from the library.")]
     public class BookCommand : ICommand
     {
-        private readonly LibraryService _libraryService;
+        private readonly LibraryProvider _libraryProvider;
 
-        [CommandParameter(0, Name = "title", Description = "Book title.")]
-        public string Title { get; set; } = "";
+        [CommandParameter(0, Name = "title", Description = "Title of the book to retrieve.")]
+        public string Title { get; init; } = "";
 
-        public BookCommand(LibraryService libraryService)
+        public BookCommand(LibraryProvider libraryProvider)
         {
-            _libraryService = libraryService;
+            _libraryProvider = libraryProvider;
         }
 
         public ValueTask ExecuteAsync(IConsole console)
         {
-            var book = _libraryService.GetBook(Title);
+            var book = _libraryProvider.TryGetBook(Title);
 
-            if (book == null)
-                throw new CommandException("Book not found.", 1);
+            if (book is null)
+                throw new CommandException("Book not found.", 10);
 
-            console.RenderBook(book);
+            console.Output.WriteBook(book);
 
             return default;
         }

CliFx.Demo/Commands/BookListCommand.cs

@@ -1,34 +1,34 @@
 using System.Threading.Tasks;
 using CliFx.Attributes;
-using CliFx.Demo.Internal;
-using CliFx.Demo.Services;
+using CliFx.Demo.Domain;
+using CliFx.Demo.Utils;
+using CliFx.Infrastructure;
 
 namespace CliFx.Demo.Commands
 {
     [Command("book list", Description = "List all books in the library.")]
     public class BookListCommand : ICommand
     {
-        private readonly LibraryService _libraryService;
+        private readonly LibraryProvider _libraryProvider;
 
-        public BookListCommand(LibraryService libraryService)
+        public BookListCommand(LibraryProvider libraryProvider)
         {
-            _libraryService = libraryService;
+            _libraryProvider = libraryProvider;
         }
 
         public ValueTask ExecuteAsync(IConsole console)
         {
-            var library = _libraryService.GetLibrary();
+            var library = _libraryProvider.GetLibrary();
 
-            var isFirst = true;
-            foreach (var book in library.Books)
+            for (var i = 0; i < library.Books.Count; i++)
             {
-                // Margin
-                if (!isFirst)
+                // Add margin
+                if (i != 0)
                     console.Output.WriteLine();
-                isFirst = false;
 
                 // Render book
-                console.RenderBook(book);
+                var book = library.Books[i];
+                console.Output.WriteBook(book);
             }
 
             return default;

CliFx.Demo/Commands/BookRemoveCommand.cs

@@ -1,31 +1,32 @@
 using System.Threading.Tasks;
 using CliFx.Attributes;
-using CliFx.Demo.Services;
+using CliFx.Demo.Domain;
 using CliFx.Exceptions;
+using CliFx.Infrastructure;
 
 namespace CliFx.Demo.Commands
 {
     [Command("book remove", Description = "Remove a book from the library.")]
     public class BookRemoveCommand : ICommand
     {
-        private readonly LibraryService _libraryService;
+        private readonly LibraryProvider _libraryProvider;
 
-        [CommandParameter(0, Name = "title", Description = "Book title.")]
-        public string Title { get; set; } = "";
+        [CommandParameter(0, Name = "title", Description = "Title of the book to remove.")]
+        public string Title { get; init; } = "";
 
-        public BookRemoveCommand(LibraryService libraryService)
+        public BookRemoveCommand(LibraryProvider libraryProvider)
         {
-            _libraryService = libraryService;
+            _libraryProvider = libraryProvider;
         }
 
         public ValueTask ExecuteAsync(IConsole console)
         {
-            var book = _libraryService.GetBook(Title);
+            var book = _libraryProvider.TryGetBook(Title);
 
-            if (book == null)
-                throw new CommandException("Book not found.", 1);
+            if (book is null)
+                throw new CommandException("Book not found.", 10);
 
-            _libraryService.RemoveBook(book);
+            _libraryProvider.RemoveBook(book);
 
             console.Output.WriteLine($"Book {Title} removed.");
 

CliFx.Demo/Domain/Book.cs

@@ -1,6 +1,6 @@
 using System;
 
-namespace CliFx.Demo.Models
+namespace CliFx.Demo.Domain
 {
     public class Book
     {

CliFx.Demo/Domain/Isbn.cs

@@ -1,6 +1,6 @@
 using System;
 
-namespace CliFx.Demo.Models
+namespace CliFx.Demo.Domain
 {
     public partial class Isbn
     {

CliFx.Demo/Domain/Library.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace CliFx.Demo.Domain
+{
+    public partial class Library
+    {
+        public IReadOnlyList<Book> Books { get; }
+
+        public Library(IReadOnlyList<Book> books)
+        {
+            Books = books;
+        }
+
+        public Library WithBook(Book book)
+        {
+            var books = Books.ToList();
+            books.Add(book);
+
+            return new Library(books);
+        }
+
+        public Library WithoutBook(Book book)
+        {
+            var books = Books.Where(b => b != book).ToArray();
+
+            return new Library(books);
+        }
+    }
+
+    public partial class Library
+    {
+        public static Library Empty { get; } = new(Array.Empty<Book>());
+    }
+}

CliFx.Demo/Domain/LibraryProvider.cs

@@ -1,13 +1,12 @@
 using System.IO;
 using System.Linq;
-using CliFx.Demo.Models;
 using Newtonsoft.Json;
 
-namespace CliFx.Demo.Services
+namespace CliFx.Demo.Domain
 {
-    public class LibraryService
+    public class LibraryProvider
     {
-        private string StorageFilePath => Path.Combine(Directory.GetCurrentDirectory(), "Data.json");
+        private static string StorageFilePath { get; } = Path.Combine(Directory.GetCurrentDirectory(), "Library.json");
 
         private void StoreLibrary(Library library)
         {
@@ -25,7 +24,7 @@ namespace CliFx.Demo.Services
             return JsonConvert.DeserializeObject<Library>(data);
         }
 
-        public Book? GetBook(string title) => GetLibrary().Books.FirstOrDefault(b => b.Title == title);
+        public Book? TryGetBook(string title) => GetLibrary().Books.FirstOrDefault(b => b.Title == title);
 
         public void AddBook(Book book)
         {

CliFx.Demo/Internal/Extensions.cs

@@ -1,29 +0,0 @@
-using System;
-using CliFx.Demo.Models;
-
-namespace CliFx.Demo.Internal
-{
-    internal static class Extensions
-    {
-        public static void RenderBook(this IConsole console, Book book)
-        {
-            // Title
-            console.WithForegroundColor(ConsoleColor.White, () => console.Output.WriteLine(book.Title));
-
-            // Author
-            console.Output.Write("  ");
-            console.Output.Write("Author: ");
-            console.WithForegroundColor(ConsoleColor.White, () => console.Output.WriteLine(book.Author));
-
-            // Published
-            console.Output.Write("  ");
-            console.Output.Write("Published: ");
-            console.WithForegroundColor(ConsoleColor.White, () => console.Output.WriteLine($"{book.Published:d}"));
-
-            // ISBN
-            console.Output.Write("  ");
-            console.Output.Write("ISBN: ");
-            console.WithForegroundColor(ConsoleColor.White, () => console.Output.WriteLine(book.Isbn));
-        }
-    }
-}

CliFx.Demo/Models/Extensions.cs

@@ -1,22 +0,0 @@
-using System.Linq;
-
-namespace CliFx.Demo.Models
-{
-    public static class Extensions
-    {
-        public static Library WithBook(this Library library, Book book)
-        {
-            var books = library.Books.ToList();
-            books.Add(book);
-
-            return new Library(books);
-        }
-
-        public static Library WithoutBook(this Library library, Book book)
-        {
-            var books = library.Books.Where(b => b != book).ToArray();
-
-            return new Library(books);
-        }
-    }
-}

CliFx.Demo/Models/Library.cs

@@ -1,20 +0,0 @@
-using System;
-using System.Collections.Generic;
-
-namespace CliFx.Demo.Models
-{
-    public partial class Library
-    {
-        public IReadOnlyList<Book> Books { get; }
-
-        public Library(IReadOnlyList<Book> books)
-        {
-            Books = books;
-        }
-    }
-
-    public partial class Library
-    {
-        public static Library Empty { get; } = new Library(Array.Empty<Book>());
-    }
-}

CliFx.Demo/Program.cs

@@ -1,7 +1,7 @@
 using System;
 using System.Threading.Tasks;
 using CliFx.Demo.Commands;
-using CliFx.Demo.Services;
+using CliFx.Demo.Domain;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace CliFx.Demo
@@ -14,7 +14,7 @@ namespace CliFx.Demo
             var services = new ServiceCollection();
 
             // Register services
-            services.AddSingleton<LibraryService>();
+            services.AddSingleton<LibraryProvider>();
 
             // Register commands
             services.AddTransient<BookCommand>();
@@ -27,8 +27,9 @@ namespace CliFx.Demo
 
         public static async Task<int> Main() =>
             await new CliApplicationBuilder()
+                .SetDescription("Demo application showcasing CliFx features.")
                 .AddCommandsFromThisAssembly()
-                .UseTypeActivator(GetServiceProvider().GetService)
+                .UseTypeActivator(GetServiceProvider().GetRequiredService)
                 .Build()
                 .RunAsync();
     }

CliFx.Demo/Readme.md

@@ -2,6 +2,4 @@
 
 Sample command line interface for managing a library of books.
 
-This demo project shows basic CliFx functionality such as command routing, argument parsing, autogenerated help text, and some other things.
-
-You can get a list of available commands by running `CliFx.Demo --help`.
+This demo project showcases basic CliFx functionality such as command routing, argument parsing, autogenerated help text.

CliFx.Demo/Utils/ConsoleExtensions.cs

@@ -0,0 +1,37 @@
+using System;
+using CliFx.Demo.Domain;
+using CliFx.Infrastructure;
+
+namespace CliFx.Demo.Utils
+{
+    internal static class ConsoleExtensions
+    {
+        public static void WriteBook(this ConsoleWriter writer, Book book)
+        {
+            // Title
+            using (writer.Console.WithForegroundColor(ConsoleColor.White))
+                writer.WriteLine(book.Title);
+
+            // Author
+            writer.Write("  ");
+            writer.Write("Author: ");
+
+            using (writer.Console.WithForegroundColor(ConsoleColor.White))
+                writer.WriteLine(book.Author);
+
+            // Published
+            writer.Write("  ");
+            writer.Write("Published: ");
+
+            using (writer.Console.WithForegroundColor(ConsoleColor.White))
+                writer.WriteLine($"{book.Published:d}");
+
+            // ISBN
+            writer.Write("  ");
+            writer.Write("ISBN: ");
+
+            using (writer.Console.WithForegroundColor(ConsoleColor.White))
+                writer.WriteLine(book.Isbn);
+        }
+    }
+}

CliFx.Tests.Dummy/CliFx.Tests.Dummy.csproj

@@ -1,13 +1,13 @@
 <Project Sdk="Microsoft.NET.Sdk">
-  <Import Project="../CliFx.props" />
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <TargetFramework>net5.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
     <ProjectReference Include="..\CliFx\CliFx.csproj" />
+    <ProjectReference Include="..\CliFx.Analyzers\CliFx.Analyzers.csproj" ReferenceOutputAssembly="false" OutputItemType="Analyzer" />
   </ItemGroup>
 
 </Project>

CliFx.Tests.Dummy/Commands/ConsoleTestCommand.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Threading.Tasks;
+using CliFx.Attributes;
+using CliFx.Infrastructure;
+
+namespace CliFx.Tests.Dummy.Commands
+{
+    [Command("console-test")]
+    public class ConsoleTestCommand : ICommand
+    {
+        public ValueTask ExecuteAsync(IConsole console)
+        {
+            var input = console.Input.ReadToEnd();
+
+            using (console.WithColors(ConsoleColor.Black, ConsoleColor.White))
+            {
+                console.Output.WriteLine(input);
+                console.Error.WriteLine(input);
+            }
+
+            return default;
+        }
+    }
+}

CliFx.Tests.Dummy/Commands/EnvironmentTestCommand.cs

@@ -0,0 +1,20 @@
+using System.Threading.Tasks;
+using CliFx.Attributes;
+using CliFx.Infrastructure;
+
+namespace CliFx.Tests.Dummy.Commands
+{
+    [Command("env-test")]
+    public class EnvironmentTestCommand : ICommand
+    {
+        [CommandOption("target", EnvironmentVariable = "ENV_TARGET")]
+        public string GreetingTarget { get; set; } = "World";
+
+        public ValueTask ExecuteAsync(IConsole console)
+        {
+            console.Output.WriteLine($"Hello {GreetingTarget}!");
+
+            return default;
+        }
+    }
+}

CliFx.Tests.Dummy/Commands/HelloWorldCommand.cs

@@ -1,19 +0,0 @@
-using System.Threading.Tasks;
-using CliFx.Attributes;
-
-namespace CliFx.Tests.Dummy.Commands
-{
-    [Command]
-    public class HelloWorldCommand : ICommand
-    {
-        [CommandOption("target", EnvironmentVariableName = "ENV_TARGET")]
-        public string Target { get; set; } = "World";
-
-        public ValueTask ExecuteAsync(IConsole console)
-        {
-            console.Output.WriteLine($"Hello {Target}!");
-
-            return default;
-        }
-    }
-}

CliFx.Tests.Dummy/Program.cs

@@ -1,8 +1,19 @@
-using System.Threading.Tasks;
+using System.Reflection;
+using System.Threading.Tasks;
 
 namespace CliFx.Tests.Dummy
 {
-    public class Program
+    // This dummy application is used in tests for scenarios
+    // that require an external process to properly verify.
+
+    public static partial class Program
+    {
+        public static Assembly Assembly { get; } = typeof(Program).Assembly;
+
+        public static string Location { get; } = Assembly.Location;
+    }
+
+    public static partial class Program
     {
         public static async Task Main() =>
             await new CliApplicationBuilder()

CliFx.Tests/ApplicationSpecs.cs

@@ -0,0 +1,86 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using CliFx.Tests.Utils;
+using FluentAssertions;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace CliFx.Tests
+{
+    public class ApplicationSpecs : SpecsBase
+    {
+        public ApplicationSpecs(ITestOutputHelper testOutput)
+            : base(testOutput)
+        {
+        }
+
+        [Fact]
+        public async Task Application_can_be_created_with_minimal_configuration()
+        {
+            // Act
+            var app = new CliApplicationBuilder()
+                .AddCommandsFromThisAssembly()
+                .UseConsole(FakeConsole)
+                .Build();
+
+            var exitCode = await app.RunAsync(
+                Array.Empty<string>(),
+                new Dictionary<string, string>()
+            );
+
+            // Assert
+            exitCode.Should().Be(0);
+        }
+
+        [Fact]
+        public async Task Application_can_be_created_with_a_fully_customized_configuration()
+        {
+            // Act
+            var app = new CliApplicationBuilder()
+                .AddCommand<NoOpCommand>()
+                .AddCommandsFrom(typeof(NoOpCommand).Assembly)
+                .AddCommands(new[] {typeof(NoOpCommand)})
+                .AddCommandsFrom(new[] {typeof(NoOpCommand).Assembly})
+                .AddCommandsFromThisAssembly()
+                .AllowDebugMode()
+                .AllowPreviewMode()
+                .SetTitle("test")
+                .SetExecutableName("test")
+                .SetVersion("test")
+                .SetDescription("test")
+                .UseConsole(FakeConsole)
+                .UseTypeActivator(Activator.CreateInstance!)
+                .Build();
+
+            var exitCode = await app.RunAsync(
+                Array.Empty<string>(),
+                new Dictionary<string, string>()
+            );
+
+            // Assert
+            exitCode.Should().Be(0);
+        }
+
+        [Fact]
+        public async Task Application_configuration_fails_if_an_invalid_command_is_registered()
+        {
+            // Act
+            var app = new CliApplicationBuilder()
+                .AddCommand(typeof(ApplicationSpecs))
+                .UseConsole(FakeConsole)
+                .Build();
+
+            var exitCode = await app.RunAsync(
+                Array.Empty<string>(),
+                new Dictionary<string, string>()
+            );
+
+            var stdErr = FakeConsole.ReadErrorString();
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.Should().Contain("not a valid command");
+        }
+    }
+}

CliFx.Tests/CancellationSpecs.cs

@@ -0,0 +1,67 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using CliFx.Tests.Utils;
+using FluentAssertions;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace CliFx.Tests
+{
+    public class CancellationSpecs : SpecsBase
+    {
+        public CancellationSpecs(ITestOutputHelper testOutput)
+            : base(testOutput)
+        {
+        }
+
+        [Fact]
+        public async Task Command_can_register_to_receive_a_cancellation_signal_from_the_console()
+        {
+            // Arrange
+            var commandType = DynamicCommandBuilder.Compile(
+                // language=cs
+                @"
+[Command]
+public class Command : ICommand
+{
+    public async ValueTask ExecuteAsync(IConsole console)
+    {
+        try
+        {
+            await Task.Delay(
+                TimeSpan.FromSeconds(3),
+                console.RegisterCancellationHandler()
+            );
+
+            console.Output.WriteLine(""Completed successfully"");
+        }
+        catch (OperationCanceledException)
+        {
+            console.Output.WriteLine(""Cancelled"");
+            throw;
+        }
+    }
+}");
+
+            var application = new CliApplicationBuilder()
+                .AddCommand(commandType)
+                .UseConsole(FakeConsole)
+                .Build();
+
+            // Act
+            FakeConsole.RequestCancellation(TimeSpan.FromSeconds(0.2));
+
+            var exitCode = await application.RunAsync(
+                Array.Empty<string>(),
+                new Dictionary<string, string>()
+            );
+
+            var stdOut = FakeConsole.ReadOutputString();
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdOut.Trim().Should().Be("Cancelled");
+        }
+    }
+}

CliFx.Tests/CliApplicationBuilderTests.cs

@@ -1,45 +0,0 @@
-using NUnit.Framework;
-using System;
-using System.IO;
-using CliFx.Tests.TestCommands;
-
-namespace CliFx.Tests
-{
-    [TestFixture]
-    public class CliApplicationBuilderTests
-    {
-        [Test(Description = "All builder methods must return without exceptions")]
-        public void Smoke_Test()
-        {
-            // Arrange
-            var builder = new CliApplicationBuilder();
-
-            // Act
-            builder
-                .AddCommand(typeof(HelloWorldDefaultCommand))
-                .AddCommandsFrom(typeof(HelloWorldDefaultCommand).Assembly)
-                .AddCommands(new[] {typeof(HelloWorldDefaultCommand)})
-                .AddCommandsFrom(new[] {typeof(HelloWorldDefaultCommand).Assembly})
-                .AddCommandsFromThisAssembly()
-                .AllowDebugMode()
-                .AllowPreviewMode()
-                .UseTitle("test")
-                .UseExecutableName("test")
-                .UseVersionText("test")
-                .UseDescription("test")
-                .UseConsole(new VirtualConsole(TextWriter.Null))
-                .UseTypeActivator(Activator.CreateInstance)
-                .Build();
-        }
-
-        [Test(Description = "Builder must be able to produce an application when no parameters are specified")]
-        public void Build_Test()
-        {
-            // Arrange
-            var builder = new CliApplicationBuilder();
-
-            // Act
-            builder.Build();
-        }
-    }
-}

CliFx.Tests/CliApplicationTests.cs

@@ -1,451 +0,0 @@
-using FluentAssertions;
-using NUnit.Framework;
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Threading;
-using System.Threading.Tasks;
-using CliFx.Tests.TestCommands;
-
-namespace CliFx.Tests
-{
-    [TestFixture]
-    public class CliApplicationTests
-    {
-        private const string TestAppName = "TestApp";
-        private const string TestVersionText = "v1.0";
-
-        private static IEnumerable<TestCaseData> GetTestCases_RunAsync()
-        {
-            yield return new TestCaseData(
-                new[] {typeof(HelloWorldDefaultCommand)},
-                new string[0],
-                new Dictionary<string, string>(),
-                "Hello world."
-            );
-
-            yield return new TestCaseData(
-                new[] {typeof(ConcatCommand)},
-                new[] {"concat", "-i", "foo", "-i", "bar", "-s", " "},
-                new Dictionary<string, string>(),
-                "foo bar"
-            );
-
-            yield return new TestCaseData(
-                new[] {typeof(ConcatCommand)},
-                new[] {"concat", "-i", "one", "two", "three", "-s", ", "},
-                new Dictionary<string, string>(),
-                "one, two, three"
-            );
-
-            yield return new TestCaseData(
-                new[] {typeof(DivideCommand)},
-                new[] {"div", "-D", "24", "-d", "8"},
-                new Dictionary<string, string>(),
-                "3"
-            );
-
-            yield return new TestCaseData(
-                new[] {typeof(HelloWorldDefaultCommand)},
-                new[] {"--version"},
-                new Dictionary<string, string>(),
-                TestVersionText
-            );
-
-            yield return new TestCaseData(
-                new[] {typeof(ConcatCommand)},
-                new[] {"--version"},
-                new Dictionary<string, string>(),
-                TestVersionText
-            );
-
-            yield return new TestCaseData(
-                new[] {typeof(ConcatCommand)},
-                new string[0],
-                new Dictionary<string, string>(),
-                null
-            );
-
-            yield return new TestCaseData(
-                new[] {typeof(ConcatCommand)},
-                new[] {"-h"},
-                new Dictionary<string, string>(),
-                null
-            );
-
-            yield return new TestCaseData(
-                new[] {typeof(ConcatCommand)},
-                new[] {"--help"},
-                new Dictionary<string, string>(),
-                null
-            );
-
-            yield return new TestCaseData(
-                new[] {typeof(ConcatCommand)},
-                new[] {"concat", "-h"},
-                new Dictionary<string, string>(),
-                null
-            );
-
-            yield return new TestCaseData(
-                new[] {typeof(ExceptionCommand)},
-                new[] {"exc", "-h"},
-                new Dictionary<string, string>(),
-                null
-            );
-
-            yield return new TestCaseData(
-                new[] {typeof(CommandExceptionCommand)},
-                new[] {"exc", "-h"},
-                new Dictionary<string, string>(),
-                null
-            );
-
-            yield return new TestCaseData(
-                new[] {typeof(ConcatCommand)},
-                new[] {"[preview]"},
-                new Dictionary<string, string>(),
-                null
-            );
-
-            yield return new TestCaseData(
-                new[] {typeof(ExceptionCommand)},
-                new[] {"[preview]", "exc"},
-                new Dictionary<string, string>(),
-                null
-            );
-
-            yield return new TestCaseData(
-                new[] {typeof(ConcatCommand)},
-                new[] {"[preview]", "concat", "-o", "value"},
-                new Dictionary<string, string>(),
-                null
-            );
-        }
-
-        private static IEnumerable<TestCaseData> GetTestCases_RunAsync_Negative()
-        {
-            yield return new TestCaseData(
-                new Type[0],
-                new string[0],
-                new Dictionary<string, string>(),
-                null, null
-            );
-
-            yield return new TestCaseData(
-                new[] {typeof(ConcatCommand)},
-                new[] {"non-existing"},
-                new Dictionary<string, string>(),
-                null, null
-            );
-
-            yield return new TestCaseData(
-                new[] {typeof(ExceptionCommand)},
-                new[] {"exc"},
-                new Dictionary<string, string>(),
-                null, null
-            );
-
-            yield return new TestCaseData(
-                new[] {typeof(CommandExceptionCommand)},
-                new[] {"exc"},
-                new Dictionary<string, string>(),
-                null, null
-            );
-
-            yield return new TestCaseData(
-                new[] {typeof(CommandExceptionCommand)},
-                new[] {"exc"},
-                new Dictionary<string, string>(),
-                null, null
-            );
-
-            yield return new TestCaseData(
-                new[] {typeof(CommandExceptionCommand)},
-                new[] {"exc", "-m", "foo bar"},
-                new Dictionary<string, string>(),
-                "foo bar", null
-            );
-
-            yield return new TestCaseData(
-                new[] {typeof(CommandExceptionCommand)},
-                new[] {"exc", "-m", "foo bar", "-c", "666"},
-                new Dictionary<string, string>(),
-                "foo bar", 666
-            );
-        }
-
-        private static IEnumerable<TestCaseData> GetTestCases_RunAsync_Help()
-        {
-            yield return new TestCaseData(
-                new[] {typeof(HelpDefaultCommand), typeof(HelpNamedCommand), typeof(HelpSubCommand)},
-                new[] {"--help"},
-                new[]
-                {
-                    TestVersionText,
-                    "Description",
-                    "HelpDefaultCommand description.",
-                    "Usage",
-                    TestAppName, "[command]", "[options]",
-                    "Options",
-                    "-a|--option-a", "OptionA description.",
-                    "-b|--option-b", "OptionB description.",
-                    "-h|--help", "Shows help text.",
-                    "--version", "Shows version information.",
-                    "Commands",
-                    "cmd", "HelpNamedCommand description.",
-                    "You can run", "to show help on a specific command."
-                }
-            );
-
-            yield return new TestCaseData(
-                new[] {typeof(HelpSubCommand)},
-                new[] {"--help"},
-                new[]
-                {
-                    TestVersionText,
-                    "Usage",
-                    TestAppName, "[command]",
-                    "Options",
-                    "-h|--help", "Shows help text.",
-                    "--version", "Shows version information.",
-                    "Commands",
-                    "cmd sub", "HelpSubCommand description.",
-                    "You can run", "to show help on a specific command."
-                }
-            );
-
-            yield return new TestCaseData(
-                new[] {typeof(HelpDefaultCommand), typeof(HelpNamedCommand), typeof(HelpSubCommand)},
-                new[] {"cmd", "--help"},
-                new[]
-                {
-                    "Description",
-                    "HelpNamedCommand description.",
-                    "Usage",
-                    TestAppName, "cmd", "[command]", "[options]",
-                    "Options",
-                    "-c|--option-c", "OptionC description.",
-                    "-d|--option-d", "OptionD description.",
-                    "-h|--help", "Shows help text.",
-                    "Commands",
-                    "sub", "HelpSubCommand description.",
-                    "You can run", "to show help on a specific command."
-                }
-            );
-
-            yield return new TestCaseData(
-                new[] {typeof(HelpDefaultCommand), typeof(HelpNamedCommand), typeof(HelpSubCommand)},
-                new[] {"cmd", "sub", "--help"},
-                new[]
-                {
-                    "Description",
-                    "HelpSubCommand description.",
-                    "Usage",
-                    TestAppName, "cmd sub", "[options]",
-                    "Options",
-                    "-e|--option-e", "OptionE description.",
-                    "-h|--help", "Shows help text."
-                }
-            );
-
-            yield return new TestCaseData(
-                new[] {typeof(ParameterCommand)},
-                new[] {"param", "cmd", "--help"},
-                new[]
-                {
-                    "Description",
-                    "Command using positional parameters",
-                    "Usage",
-                    TestAppName, "param cmd", "<first>", "<parameterb>", "<third list...>", "[options]",
-                    "Parameters",
-                    "* first",
-                    "* parameterb",
-                    "* third list", "A list of numbers",
-                    "Options",
-                    "-o|--option",
-                    "-h|--help", "Shows help text."
-                }
-            );
-
-            yield return new TestCaseData(
-                new[] {typeof(AllRequiredOptionsCommand)},
-                new[] {"allrequired", "--help"},
-                new[]
-                {
-                    "Description",
-                    "AllRequiredOptionsCommand description.",
-                    "Usage",
-                    TestAppName, "allrequired --option-f <value> --option-g <value>"
-                }
-            );
-
-            yield return new TestCaseData(
-                new[] {typeof(SomeRequiredOptionsCommand)},
-                new[] {"somerequired", "--help"},
-                new[]
-                {
-                    "Description",
-                    "SomeRequiredOptionsCommand description.",
-                    "Usage",
-                    TestAppName, "somerequired --option-f <value> [options]"
-                }
-            );
-
-            yield return new TestCaseData(
-                new[] {typeof(EnvironmentVariableCommand)},
-                new[] {"--help"},
-                new[]
-                {
-                    "Environment variable:", "ENV_SINGLE_VALUE"
-                }
-            );
-
-            yield return new TestCaseData(
-                new[] {typeof(ConcatCommand)},
-                new[] {"concat", "--help"},
-                new[]
-                {
-                    "Usage",
-                    TestAppName, "concat", "-i", "<values...>", "[options]",
-                }
-            );
-        }
-
-        [TestCaseSource(nameof(GetTestCases_RunAsync))]
-        public async Task RunAsync_Test(
-            IReadOnlyList<Type> commandTypes,
-            IReadOnlyList<string> commandLineArguments,
-            IReadOnlyDictionary<string, string> environmentVariables,
-            string? expectedStdOut = null)
-        {
-            // Arrange
-            await using var stdOutStream = new StringWriter();
-            var console = new VirtualConsole(stdOutStream);
-
-            var application = new CliApplicationBuilder()
-                .AddCommands(commandTypes)
-                .UseTitle(TestAppName)
-                .UseExecutableName(TestAppName)
-                .UseVersionText(TestVersionText)
-                .UseConsole(console)
-                .Build();
-
-            // Act
-            var exitCode = await application.RunAsync(commandLineArguments, environmentVariables);
-            var stdOut = stdOutStream.ToString().Trim();
-
-            // Assert
-            exitCode.Should().Be(0);
-            stdOut.Should().NotBeNullOrWhiteSpace();
-
-            if (expectedStdOut != null)
-                stdOut.Should().Be(expectedStdOut);
-
-            Console.WriteLine(stdOut);
-        }
-
-        [TestCaseSource(nameof(GetTestCases_RunAsync_Negative))]
-        public async Task RunAsync_Negative_Test(
-            IReadOnlyList<Type> commandTypes,
-            IReadOnlyList<string> commandLineArguments,
-            IReadOnlyDictionary<string, string> environmentVariables,
-            string? expectedStdErr = null,
-            int? expectedExitCode = null)
-        {
-            // Arrange
-            await using var stdErrStream = new StringWriter();
-            var console = new VirtualConsole(TextWriter.Null, stdErrStream);
-
-            var application = new CliApplicationBuilder()
-                .AddCommands(commandTypes)
-                .UseTitle(TestAppName)
-                .UseExecutableName(TestAppName)
-                .UseVersionText(TestVersionText)
-                .UseConsole(console)
-                .Build();
-
-            // Act
-            var exitCode = await application.RunAsync(commandLineArguments, environmentVariables);
-            var stderr = stdErrStream.ToString().Trim();
-
-            // Assert
-            exitCode.Should().NotBe(0);
-            stderr.Should().NotBeNullOrWhiteSpace();
-
-            if (expectedExitCode != null)
-                exitCode.Should().Be(expectedExitCode);
-
-            if (expectedStdErr != null)
-                stderr.Should().Be(expectedStdErr);
-
-            Console.WriteLine(stderr);
-        }
-
-        [TestCaseSource(nameof(GetTestCases_RunAsync_Help))]
-        public async Task RunAsync_Help_Test(
-            IReadOnlyList<Type> commandTypes,
-            IReadOnlyList<string> commandLineArguments,
-            IReadOnlyList<string>? expectedSubstrings = null)
-        {
-            // Arrange
-            await using var stdOutStream = new StringWriter();
-            var console = new VirtualConsole(stdOutStream);
-
-            var application = new CliApplicationBuilder()
-                .AddCommands(commandTypes)
-                .UseTitle(TestAppName)
-                .UseExecutableName(TestAppName)
-                .UseVersionText(TestVersionText)
-                .UseConsole(console)
-                .Build();
-
-            var environmentVariables = new Dictionary<string, string>();
-
-            // Act
-            var exitCode = await application.RunAsync(commandLineArguments, environmentVariables);
-            var stdOut = stdOutStream.ToString().Trim();
-
-            // Assert
-            exitCode.Should().Be(0);
-            stdOut.Should().NotBeNullOrWhiteSpace();
-
-            if (expectedSubstrings != null)
-                stdOut.Should().ContainAll(expectedSubstrings);
-
-            Console.WriteLine(stdOut);
-        }
-
-        [Test]
-        public async Task RunAsync_Cancellation_Test()
-        {
-            // Arrange
-            using var cancellationTokenSource = new CancellationTokenSource();
-
-            await using var stdOutStream = new StringWriter();
-            await using var stdErrStream = new StringWriter();
-            var console = new VirtualConsole(stdOutStream, stdErrStream, cancellationTokenSource.Token);
-
-            var application = new CliApplicationBuilder()
-                .AddCommand(typeof(CancellableCommand))
-                .UseConsole(console)
-                .Build();
-
-            var commandLineArguments = new[] {"cancel"};
-            var environmentVariables = new Dictionary<string, string>();
-
-            // Act
-            cancellationTokenSource.CancelAfter(TimeSpan.FromSeconds(0.2));
-            var exitCode = await application.RunAsync(commandLineArguments, environmentVariables);
-            var stdOut = stdOutStream.ToString().Trim();
-            var stdErr = stdErrStream.ToString().Trim();
-
-            // Assert
-            exitCode.Should().NotBe(0);
-            stdOut.Should().BeNullOrWhiteSpace();
-            stdErr.Should().NotBeNullOrWhiteSpace();
-
-            Console.WriteLine(stdErr);
-        }
-    }
-}

CliFx.Tests/CliFx.Tests.csproj

@@ -1,22 +1,26 @@
 <Project Sdk="Microsoft.NET.Sdk">
-  <Import Project="../CliFx.props" />
 
   <PropertyGroup>
-    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <TargetFramework>net5.0</TargetFramework>
     <IsPackable>false</IsPackable>
     <IsTestProject>true</IsTestProject>
     <CollectCoverage>true</CollectCoverage>
     <CoverletOutputFormat>opencover</CoverletOutputFormat>
-    <CoverletOutput>bin/$(Configuration)/Coverage.xml</CoverletOutput>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="CliWrap" Version="2.5.0" />
-    <PackageReference Include="FluentAssertions" Version="5.10.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.4.0" />
-    <PackageReference Include="NUnit" Version="3.12.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="3.16.1" />
-    <PackageReference Include="coverlet.msbuild" Version="2.8.0" PrivateAssets="all" />
+    <Content Include="xunit.runner.json" CopyToOutputDirectory="PreserveNewest" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="CliWrap" Version="3.3.1" />
+    <PackageReference Include="FluentAssertions" Version="5.10.3" />
+    <PackageReference Include="GitHubActionsTestLogger" Version="1.2.0" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="3.4.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.9.1" />
+    <PackageReference Include="xunit" Version="2.4.1" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3" PrivateAssets="all" />
+    <PackageReference Include="coverlet.msbuild" Version="3.0.3" PrivateAssets="all" />
   </ItemGroup>
 
   <ItemGroup>
@@ -24,8 +28,12 @@
     <ProjectReference Include="..\CliFx\CliFx.csproj" />
   </ItemGroup>
 
-  <Target Name="Copy dummy's runtime config" AfterTargets="AfterBuild">
-    <Copy SourceFiles="../CliFx.Tests.Dummy/bin/$(Configuration)/$(TargetFramework)/CliFx.Tests.Dummy.runtimeconfig.json" DestinationFiles="$(OutputPath)CliFx.Tests.Dummy.runtimeconfig.json" />
-  </Target>
+  <ItemGroup>
+    <None Include="../CliFx.Tests.Dummy/bin/$(Configuration)/$(TargetFramework)/CliFx.Tests.Dummy.runtimeconfig.json">
+      <Link>CliFx.Tests.Dummy.runtimeconfig.json</Link>
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+      <Visible>false</Visible>
+    </None>
+  </ItemGroup>
 
 </Project>

CliFx.Tests/ConsoleSpecs.cs

@@ -0,0 +1,139 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using CliFx.Tests.Utils;
+using CliWrap;
+using CliWrap.Buffered;
+using FluentAssertions;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace CliFx.Tests
+{
+    public class ConsoleSpecs : SpecsBase
+    {
+        public ConsoleSpecs(ITestOutputHelper testOutput)
+            : base(testOutput)
+        {
+        }
+
+        [Fact]
+        public async Task Real_console_maps_directly_to_system_console()
+        {
+            // Can't verify our own console output, so using an
+            // external process for this test.
+
+            // Arrange
+            var command = "Hello world" | Cli.Wrap("dotnet")
+                .WithArguments(a => a
+                    .Add(Dummy.Program.Location)
+                    .Add("console-test"));
+
+            // Act
+            var result = await command.ExecuteBufferedAsync();
+
+            // Assert
+            result.StandardOutput.Trim().Should().Be("Hello world");
+            result.StandardError.Trim().Should().Be("Hello world");
+        }
+
+        [Fact]
+        public async Task Fake_console_does_not_leak_to_system_console()
+        {
+            // Arrange
+            var commandType = DynamicCommandBuilder.Compile(
+                // language=cs
+                @"
+[Command]
+public class Command : ICommand
+{   
+    public ValueTask ExecuteAsync(IConsole console)
+    {
+        console.ResetColor();
+        console.ForegroundColor = ConsoleColor.DarkMagenta;
+        console.BackgroundColor = ConsoleColor.DarkMagenta;
+        console.CursorLeft = 42;
+        console.CursorTop = 24;
+
+        console.Output.WriteLine(""Hello "");
+        console.Error.WriteLine(""world!"");
+
+        return default;
+    }
+}
+");
+
+            var application = new CliApplicationBuilder()
+                .AddCommand(commandType)
+                .UseConsole(FakeConsole)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(
+                Array.Empty<string>(),
+                new Dictionary<string, string>()
+            );
+
+            // Assert
+            exitCode.Should().Be(0);
+
+            Console.OpenStandardInput().Should().NotBe(FakeConsole.Input.BaseStream);
+            Console.OpenStandardOutput().Should().NotBe(FakeConsole.Output.BaseStream);
+            Console.OpenStandardError().Should().NotBe(FakeConsole.Error.BaseStream);
+
+            Console.ForegroundColor.Should().NotBe(ConsoleColor.DarkMagenta);
+            Console.BackgroundColor.Should().NotBe(ConsoleColor.DarkMagenta);
+
+            // This fails because tests don't spawn a console window
+            //Console.CursorLeft.Should().NotBe(42);
+            //Console.CursorTop.Should().NotBe(24);
+
+            FakeConsole.IsInputRedirected.Should().BeTrue();
+            FakeConsole.IsOutputRedirected.Should().BeTrue();
+            FakeConsole.IsErrorRedirected.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Fake_console_can_be_used_with_an_in_memory_backing_store()
+        {
+            // Arrange
+            var commandType = DynamicCommandBuilder.Compile(
+                // language=cs
+                @"
+[Command]
+public class Command : ICommand
+{   
+    public ValueTask ExecuteAsync(IConsole console)
+    {
+        var input = console.Input.ReadToEnd();
+        console.Output.WriteLine(input);
+        console.Error.WriteLine(input);
+
+        return default;
+    }
+}
+");
+
+            var application = new CliApplicationBuilder()
+                .AddCommand(commandType)
+                .UseConsole(FakeConsole)
+                .Build();
+
+            // Act
+            FakeConsole.WriteInput("Hello world");
+
+            var exitCode = await application.RunAsync(
+                Array.Empty<string>(),
+                new Dictionary<string, string>()
+            );
+
+            var stdOut = FakeConsole.ReadOutputString();
+            var stdErr = FakeConsole.ReadErrorString();
+
+            // Assert
+            exitCode.Should().Be(0);
+            stdOut.Trim().Should().Be("Hello world");
+            stdErr.Trim().Should().Be("Hello world");
+        }
+    }
+}

CliFx.Tests/ConversionSpecs.cs

@@ -0,0 +1,950 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using CliFx.Tests.Utils;
+using CliFx.Tests.Utils.Extensions;
+using FluentAssertions;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace CliFx.Tests
+{
+    public class ConversionSpecs : SpecsBase
+    {
+        public ConversionSpecs(ITestOutputHelper testOutput)
+            : base(testOutput)
+        {
+        }
+
+        [Fact]
+        public async Task Parameter_or_option_value_can_be_converted_to_a_string()
+        {
+            // Arrange
+            var commandType = DynamicCommandBuilder.Compile(
+                // language=cs
+                @"
+[Command]
+public class Command : ICommand
+{
+    [CommandOption('f')]
+    public string Foo { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console)
+    {
+        console.Output.WriteLine(Foo);
+        return default;
+    }
+}
+");
+            var application = new CliApplicationBuilder()
+                .AddCommand(commandType)
+                .UseConsole(FakeConsole)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(
+                new[] {"-f", "xyz"},
+                new Dictionary<string, string>()
+            );
+
+            var stdOut = FakeConsole.ReadOutputString();
+
+            // Assert
+            exitCode.Should().Be(0);
+            stdOut.Trim().Should().Be("xyz");
+        }
+
+        [Fact]
+        public async Task Parameter_or_option_value_can_be_converted_to_an_object()
+        {
+            // Arrange
+            var commandType = DynamicCommandBuilder.Compile(
+                // language=cs
+                @"
+[Command]
+public class Command : ICommand
+{
+    [CommandOption('f')]
+    public object Foo { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console)
+    {
+        console.Output.WriteLine(Foo);
+        return default;
+    }
+}
+");
+            var application = new CliApplicationBuilder()
+                .AddCommand(commandType)
+                .UseConsole(FakeConsole)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(
+                new[] {"-f", "xyz"},
+                new Dictionary<string, string>()
+            );
+
+            var stdOut = FakeConsole.ReadOutputString();
+
+            // Assert
+            exitCode.Should().Be(0);
+            stdOut.Trim().Should().Be("xyz");
+        }
+
+        [Fact]
+        public async Task Parameter_or_option_value_can_be_converted_to_a_boolean()
+        {
+            // Arrange
+            var commandType = DynamicCommandBuilder.Compile(
+                // language=cs
+                @"
+[Command]
+public class Command : ICommand
+{
+    [CommandOption('f')]
+    public bool Foo { get; set; }
+    
+    [CommandOption('b')]
+    public bool Bar { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console)
+    {
+        console.Output.WriteLine(""Foo = "" + Foo);
+        console.Output.WriteLine(""Bar = "" + Bar);
+
+        return default;
+    }
+}
+");
+            var application = new CliApplicationBuilder()
+                .AddCommand(commandType)
+                .UseConsole(FakeConsole)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(
+                new[] {"-f", "true", "-b", "false"},
+                new Dictionary<string, string>()
+            );
+
+            var stdOut = FakeConsole.ReadOutputString();
+
+            // Assert
+            exitCode.Should().Be(0);
+            stdOut.Should().ConsistOfLines(
+                "Foo = True",
+                "Bar = False"
+            );
+        }
+
+        [Fact]
+        public async Task Parameter_or_option_value_can_be_converted_to_a_boolean_with_implicit_value()
+        {
+            // Arrange
+            var commandType = DynamicCommandBuilder.Compile(
+                // language=cs
+                @"
+[Command]
+public class Command : ICommand
+{
+    [CommandOption('f')]
+    public bool Foo { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console)
+    {
+        console.Output.WriteLine(Foo);
+        return default;
+    }
+}
+");
+            var application = new CliApplicationBuilder()
+                .AddCommand(commandType)
+                .UseConsole(FakeConsole)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(
+                new[] {"-f"},
+                new Dictionary<string, string>()
+            );
+
+            var stdOut = FakeConsole.ReadOutputString();
+
+            // Assert
+            exitCode.Should().Be(0);
+            stdOut.Trim().Should().Be("True");
+        }
+
+        [Fact]
+        public async Task Parameter_or_option_value_can_be_converted_to_an_integer()
+        {
+            // Arrange
+            var commandType = DynamicCommandBuilder.Compile(
+                // language=cs
+                @"
+[Command]
+public class Command : ICommand
+{
+    [CommandOption('f')]
+    public int Foo { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console)
+    {
+        console.Output.WriteLine(Foo);
+        return default;
+    }
+}
+");
+            var application = new CliApplicationBuilder()
+                .AddCommand(commandType)
+                .UseConsole(FakeConsole)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(
+                new[] {"-f", "32"},
+                new Dictionary<string, string>()
+            );
+
+            var stdOut = FakeConsole.ReadOutputString();
+
+            // Assert
+            exitCode.Should().Be(0);
+            stdOut.Trim().Should().Be("32");
+        }
+
+        [Fact]
+        public async Task Parameter_or_option_value_can_be_converted_to_a_double()
+        {
+            // Arrange
+            var commandType = DynamicCommandBuilder.Compile(
+                // language=cs
+                @"
+[Command]
+public class Command : ICommand
+{
+    [CommandOption('f')]
+    public double Foo { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console)
+    {
+        console.Output.WriteLine(Foo.ToString(CultureInfo.InvariantCulture));
+        return default;
+    }
+}
+");
+            var application = new CliApplicationBuilder()
+                .AddCommand(commandType)
+                .UseConsole(FakeConsole)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(
+                new[] {"-f", "32.14"},
+                new Dictionary<string, string>()
+            );
+
+            var stdOut = FakeConsole.ReadOutputString();
+
+            // Assert
+            exitCode.Should().Be(0);
+            stdOut.Trim().Should().Be("32.14");
+        }
+
+        [Fact]
+        public async Task Parameter_or_option_value_can_be_converted_to_DateTimeOffset()
+        {
+            // Arrange
+            var commandType = DynamicCommandBuilder.Compile(
+                // language=cs
+                @"
+[Command]
+public class Command : ICommand
+{
+    [CommandOption('f')]
+    public DateTimeOffset Foo { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console)
+    {
+        console.Output.WriteLine(Foo.ToString(""u"", CultureInfo.InvariantCulture));
+        return default;
+    }
+}
+");
+            var application = new CliApplicationBuilder()
+                .AddCommand(commandType)
+                .UseConsole(FakeConsole)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(
+                new[] {"-f", "1995-04-28Z"},
+                new Dictionary<string, string>()
+            );
+
+            var stdOut = FakeConsole.ReadOutputString();
+
+            // Assert
+            exitCode.Should().Be(0);
+            stdOut.Trim().Should().Be("1995-04-28 00:00:00Z");
+        }
+
+        [Fact]
+        public async Task Parameter_or_option_value_can_be_converted_to_a_TimeSpan()
+        {
+            // Arrange
+            var commandType = DynamicCommandBuilder.Compile(
+                // language=cs
+                @"
+[Command]
+public class Command : ICommand
+{
+    [CommandOption('f')]
+    public TimeSpan Foo { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console)
+    {
+        console.Output.WriteLine(Foo.ToString(null, CultureInfo.InvariantCulture));
+        return default;
+    }
+}
+");
+            var application = new CliApplicationBuilder()
+                .AddCommand(commandType)
+                .UseConsole(FakeConsole)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(
+                new[] {"-f", "12:34:56"},
+                new Dictionary<string, string>()
+            );
+
+            var stdOut = FakeConsole.ReadOutputString();
+
+            // Assert
+            exitCode.Should().Be(0);
+            stdOut.Trim().Should().Be("12:34:56");
+        }
+
+        [Fact]
+        public async Task Parameter_or_option_value_can_be_converted_to_an_enum()
+        {
+            // Arrange
+            var commandType = DynamicCommandBuilder.Compile(
+                // language=cs
+                @"
+public enum CustomEnum { One = 1, Two = 2, Three = 3 }
+
+[Command]
+public class Command : ICommand
+{
+    [CommandOption('f')]
+    public CustomEnum Foo { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console)
+    {
+        console.Output.WriteLine((int) Foo);
+        return default;
+    }
+}
+");
+            var application = new CliApplicationBuilder()
+                .AddCommand(commandType)
+                .UseConsole(FakeConsole)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(
+                new[] {"-f", "two"},
+                new Dictionary<string, string>()
+            );
+
+            var stdOut = FakeConsole.ReadOutputString();
+
+            // Assert
+            exitCode.Should().Be(0);
+            stdOut.Trim().Should().Be("2");
+        }
+
+        [Fact]
+        public async Task Parameter_or_option_value_can_be_converted_to_a_nullable_integer()
+        {
+            // Arrange
+            var commandType = DynamicCommandBuilder.Compile(
+                // language=cs
+                @"
+[Command]
+public class Command : ICommand
+{
+    [CommandOption('f')]
+    public int? Foo { get; set; }
+    
+    [CommandOption('b')]
+    public int? Bar { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console)
+    {
+        console.Output.WriteLine(""Foo = "" + Foo);
+        console.Output.WriteLine(""Bar = "" + Bar);
+
+        return default;
+    }
+}
+");
+            var application = new CliApplicationBuilder()
+                .AddCommand(commandType)
+                .UseConsole(FakeConsole)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(
+                new[] {"-b", "123"},
+                new Dictionary<string, string>()
+            );
+
+            var stdOut = FakeConsole.ReadOutputString();
+
+            // Assert
+            exitCode.Should().Be(0);
+            stdOut.Should().ConsistOfLines(
+                "Foo = ",
+                "Bar = 123"
+            );
+        }
+
+        [Fact]
+        public async Task Parameter_or_option_value_can_be_converted_to_a_nullable_enum()
+        {
+            // Arrange
+            var commandType = DynamicCommandBuilder.Compile(
+                // language=cs
+                @"
+public enum CustomEnum { One = 1, Two = 2, Three = 3 }
+
+[Command]
+public class Command : ICommand
+{
+    [CommandOption('f')]
+    public CustomEnum? Foo { get; set; }
+    
+    [CommandOption('b')]
+    public CustomEnum? Bar { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console)
+    {
+        console.Output.WriteLine(""Foo = "" + (int?) Foo);
+        console.Output.WriteLine(""Bar = "" + (int?) Bar);
+
+        return default;
+    }
+}
+");
+            var application = new CliApplicationBuilder()
+                .AddCommand(commandType)
+                .UseConsole(FakeConsole)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(
+                new[] {"-b", "two"},
+                new Dictionary<string, string>()
+            );
+
+            var stdOut = FakeConsole.ReadOutputString();
+
+            // Assert
+            exitCode.Should().Be(0);
+            stdOut.Should().ConsistOfLines(
+                "Foo = ",
+                "Bar = 2"
+            );
+        }
+
+        [Fact]
+        public async Task Parameter_or_option_value_can_be_converted_to_a_type_that_has_a_constructor_accepting_a_string()
+        {
+            // Arrange
+            var commandType = DynamicCommandBuilder.Compile(
+                // language=cs
+                @"
+public class CustomType
+{
+    public string Value { get; }
+    
+    public CustomType(string value) => Value = value;
+}
+
+[Command]
+public class Command : ICommand
+{
+    [CommandOption('f')]
+    public CustomType Foo { get; set; }
+    
+    public ValueTask ExecuteAsync(IConsole console)
+    {
+        console.Output.WriteLine(Foo.Value);
+        return default;
+    }
+}
+");
+            var application = new CliApplicationBuilder()
+                .AddCommand(commandType)
+                .UseConsole(FakeConsole)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(
+                new[] {"-f", "xyz"},
+                new Dictionary<string, string>()
+            );
+
+            var stdOut = FakeConsole.ReadOutputString();
+
+            // Assert
+            exitCode.Should().Be(0);
+            stdOut.Trim().Should().Be("xyz");
+        }
+
+        [Fact]
+        public async Task Parameter_or_option_value_can_be_converted_to_a_type_that_has_a_static_parse_method()
+        {
+            // Arrange
+            var commandType = DynamicCommandBuilder.Compile(
+                // language=cs
+                @"
+public class CustomTypeA
+{
+    public string Value { get; }
+    
+    private CustomTypeA(string value) => Value = value;
+    
+    public static CustomTypeA Parse(string value) => 
+        new CustomTypeA(value);
+}
+
+public class CustomTypeB
+{
+    public string Value { get; }
+    
+    private CustomTypeB(string value) => Value = value;
+    
+    public static CustomTypeB Parse(string value, IFormatProvider formatProvider) =>
+        new CustomTypeB(value);
+}
+
+[Command]
+public class Command : ICommand
+{
+    [CommandOption('f')]
+    public CustomTypeA Foo { get; set; }
+    
+    [CommandOption('b')]
+    public CustomTypeB Bar { get; set; }
+    
+    public ValueTask ExecuteAsync(IConsole console)
+    {
+        console.Output.WriteLine(""Foo = "" + Foo.Value);
+        console.Output.WriteLine(""Bar = "" + Bar.Value);
+
+        return default;
+    }
+}
+");
+            var application = new CliApplicationBuilder()
+                .AddCommand(commandType)
+                .UseConsole(FakeConsole)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(
+                new[] {"-f", "hello", "-b", "world"},
+                new Dictionary<string, string>()
+            );
+
+            var stdOut = FakeConsole.ReadOutputString();
+
+            // Assert
+            exitCode.Should().Be(0);
+            stdOut.Should().ConsistOfLines(
+                "Foo = hello",
+                "Bar = world"
+            );
+        }
+
+        [Fact]
+        public async Task Parameter_or_option_value_can_be_converted_using_a_custom_converter()
+        {
+            // Arrange
+            var commandType = DynamicCommandBuilder.Compile(
+                // language=cs
+                @"
+public class CustomConverter : BindingConverter<int>
+{
+    public override int Convert(string rawValue) =>
+        rawValue.Length;
+}
+
+[Command]
+public class Command : ICommand
+{
+    [CommandOption('f', Converter = typeof(CustomConverter))]
+    public int Foo { get; set; }
+    
+    public ValueTask ExecuteAsync(IConsole console)
+    {
+        console.Output.WriteLine(Foo);
+        return default;
+    }
+}
+");
+            var application = new CliApplicationBuilder()
+                .AddCommand(commandType)
+                .UseConsole(FakeConsole)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(
+                new[] {"-f", "hello world"},
+                new Dictionary<string, string>()
+            );
+
+            var stdOut = FakeConsole.ReadOutputString();
+
+            // Assert
+            exitCode.Should().Be(0);
+            stdOut.Trim().Should().Be("11");
+        }
+
+        [Fact]
+        public async Task Parameter_or_option_value_can_be_converted_to_an_array_of_strings()
+        {
+            // Arrange
+            var commandType = DynamicCommandBuilder.Compile(
+                // language=cs
+                @"
+[Command]
+public class Command : ICommand
+{
+    [CommandOption('f')]
+    public string[] Foo { get; set; }
+    
+    public ValueTask ExecuteAsync(IConsole console)
+    {
+        foreach (var i in Foo)
+            console.Output.WriteLine(i);
+
+        return default;
+    }
+}
+");
+            var application = new CliApplicationBuilder()
+                .AddCommand(commandType)
+                .UseConsole(FakeConsole)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(
+                new[] {"-f", "one", "two", "three"},
+                new Dictionary<string, string>()
+            );
+
+            var stdOut = FakeConsole.ReadOutputString();
+
+            // Assert
+            exitCode.Should().Be(0);
+            stdOut.Should().ConsistOfLines(
+                "one",
+                "two",
+                "three"
+            );
+        }
+
+        [Fact]
+        public async Task Parameter_or_option_value_can_be_converted_to_a_read_only_list_of_strings()
+        {
+            // Arrange
+            var commandType = DynamicCommandBuilder.Compile(
+                // language=cs
+                @"
+[Command]
+public class Command : ICommand
+{
+    [CommandOption('f')]
+    public IReadOnlyList<string> Foo { get; set; }
+    
+    public ValueTask ExecuteAsync(IConsole console)
+    {
+        foreach (var i in Foo)
+            console.Output.WriteLine(i);
+
+        return default;
+    }
+}
+");
+            var application = new CliApplicationBuilder()
+                .AddCommand(commandType)
+                .UseConsole(FakeConsole)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(
+                new[] {"-f", "one", "two", "three"},
+                new Dictionary<string, string>()
+            );
+
+            var stdOut = FakeConsole.ReadOutputString();
+
+            // Assert
+            exitCode.Should().Be(0);
+            stdOut.Should().ConsistOfLines(
+                "one",
+                "two",
+                "three"
+            );
+        }
+
+        [Fact]
+        public async Task Parameter_or_option_value_can_be_converted_to_a_list_of_strings()
+        {
+            // Arrange
+            var commandType = DynamicCommandBuilder.Compile(
+                // language=cs
+                @"
+[Command]
+public class Command : ICommand
+{
+    [CommandOption('f')]
+    public List<string> Foo { get; set; }
+    
+    public ValueTask ExecuteAsync(IConsole console)
+    {
+        foreach (var i in Foo)
+            console.Output.WriteLine(i);
+
+        return default;
+    }
+}
+");
+            var application = new CliApplicationBuilder()
+                .AddCommand(commandType)
+                .UseConsole(FakeConsole)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(
+                new[] {"-f", "one", "two", "three"},
+                new Dictionary<string, string>()
+            );
+
+            var stdOut = FakeConsole.ReadOutputString();
+
+            // Assert
+            exitCode.Should().Be(0);
+            stdOut.Should().ConsistOfLines(
+                "one",
+                "two",
+                "three"
+            );
+        }
+
+        [Fact]
+        public async Task Parameter_or_option_value_can_be_converted_to_an_array_of_integers()
+        {
+            // Arrange
+            var commandType = DynamicCommandBuilder.Compile(
+                // language=cs
+                @"
+[Command]
+public class Command : ICommand
+{
+    [CommandOption('f')]
+    public int[] Foo { get; set; }
+    
+    public ValueTask ExecuteAsync(IConsole console)
+    {
+        foreach (var i in Foo)
+            console.Output.WriteLine(i);
+
+        return default;
+    }
+}
+");
+            var application = new CliApplicationBuilder()
+                .AddCommand(commandType)
+                .UseConsole(FakeConsole)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(
+                new[] {"-f", "1", "13", "27"},
+                new Dictionary<string, string>()
+            );
+
+            var stdOut = FakeConsole.ReadOutputString();
+
+            // Assert
+            exitCode.Should().Be(0);
+            stdOut.Should().ConsistOfLines(
+                "1",
+                "13",
+                "27"
+            );
+        }
+
+        [Fact]
+        public async Task Parameter_or_option_value_conversion_fails_if_the_value_cannot_be_converted_to_the_target_type()
+        {
+            // Arrange
+            var commandType = DynamicCommandBuilder.Compile(
+                // language=cs
+                @"
+[Command]
+public class Command : ICommand
+{
+    [CommandOption('f')]
+    public int Foo { get; set; }
+    
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}
+");
+            var application = new CliApplicationBuilder()
+                .AddCommand(commandType)
+                .UseConsole(FakeConsole)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(
+                new[] {"-f", "12.34"},
+                new Dictionary<string, string>()
+            );
+
+            var stdErr = FakeConsole.ReadErrorString();
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.Should().NotBeNullOrWhiteSpace();
+        }
+
+        [Fact]
+        public async Task Parameter_or_option_value_conversion_fails_if_the_target_type_is_not_supported()
+        {
+            // Arrange
+            var commandType = DynamicCommandBuilder.Compile(
+                // language=cs
+                @"
+public class CustomType {}
+
+[Command]
+public class Command : ICommand
+{
+    [CommandOption('f')]
+    public CustomType Foo { get; set; }
+    
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}
+");
+            var application = new CliApplicationBuilder()
+                .AddCommand(commandType)
+                .UseConsole(FakeConsole)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(
+                new[] {"-f", "xyz"},
+                new Dictionary<string, string>()
+            );
+
+            var stdErr = FakeConsole.ReadErrorString();
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.Should().Contain("has an unsupported underlying property type");
+        }
+
+        [Fact]
+        public async Task Parameter_or_option_value_conversion_fails_if_the_target_non_scalar_type_is_not_supported()
+        {
+            // Arrange
+            var commandType = DynamicCommandBuilder.Compile(
+                // language=cs
+                @"
+public class CustomType : IEnumerable<object>
+{
+    public IEnumerator<object> GetEnumerator() => Enumerable.Empty<object>().GetEnumerator();
+    
+    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+}
+
+[Command]
+public class Command : ICommand
+{
+    [CommandOption('f')]
+    public CustomType Foo { get; set; }
+    
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}
+");
+            var application = new CliApplicationBuilder()
+                .AddCommand(commandType)
+                .UseConsole(FakeConsole)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(
+                new[] {"-f", "one", "two"},
+                new Dictionary<string, string>()
+            );
+
+            var stdErr = FakeConsole.ReadErrorString();
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.Should().Contain("has an unsupported underlying property type");
+        }
+
+        [Fact]
+        public async Task Parameter_or_option_value_conversion_fails_if_one_of_the_validators_fail()
+        {
+            // Arrange
+            var commandType = DynamicCommandBuilder.Compile(
+                // language=cs
+                @"
+public class ValidatorA : BindingValidator<int>
+{
+    public override BindingValidationError Validate(int value) => Ok();
+}
+
+public class ValidatorB : BindingValidator<int>
+{
+    public override BindingValidationError Validate(int value) => Error(""Hello world"");
+}
+
+[Command]
+public class Command : ICommand
+{
+    [CommandOption('f', Validators = new[] {typeof(ValidatorA), typeof(ValidatorB)})]
+    public int Foo { get; set; }
+    
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}
+");
+            var application = new CliApplicationBuilder()
+                .AddCommand(commandType)
+                .UseConsole(FakeConsole)
+                .Build();
+
+            // Act
+            var exitCode = await application.RunAsync(
+                new[] {"-f", "12"},
+                new Dictionary<string, string>()
+            );
+
+            var stdErr = FakeConsole.ReadErrorString();
+
+            // Assert
+            exitCode.Should().NotBe(0);
+            stdErr.Should().Contain("Hello world");
+        }
+    }
+}

CliFx.Tests/DefaultCommandFactoryTests.cs

@@ -1,48 +0,0 @@
-using System;
-using System.Collections.Generic;
-using CliFx.Exceptions;
-using CliFx.Tests.TestCommands;
-using CliFx.Tests.TestCustomTypes;
-using FluentAssertions;
-using NUnit.Framework;
-
-namespace CliFx.Tests
-{
-    [TestFixture]
-    public class DefaultCommandFactoryTests
-    {
-        private static IEnumerable<TestCaseData> GetTestCases_CreateInstance()
-        {
-            yield return new TestCaseData(typeof(HelloWorldDefaultCommand));
-        }
-
-        private static IEnumerable<TestCaseData> GetTestCases_CreateInstance_Negative()
-        {
-            yield return new TestCaseData(typeof(TestNonStringParseable));
-        }
-
-        [TestCaseSource(nameof(GetTestCases_CreateInstance))]
-        public void CreateInstance_Test(Type type)
-        {
-            // Arrange
-            var activator = new DefaultTypeActivator();
-
-            // Act
-            var obj = activator.CreateInstance(type);
-
-            // Assert
-            obj.Should().BeOfType(type);
-        }
-
-        [TestCaseSource(nameof(GetTestCases_CreateInstance_Negative))]
-        public void CreateInstance_Negative_Test(Type type)
-        {
-            // Arrange
-            var activator = new DefaultTypeActivator();
-
-            // Act & Assert
-            var ex = Assert.Throws<CliFxException>(() => activator.CreateInstance(type));
-            Console.WriteLine(ex.Message);
-        }
-    }
-}