Update version

Update NuGet packages
More consistent code style
2025-10-25 15:19:17 +00:00 · 2022-05-09 23:27:55 +03:00 · 2022-05-09 23:27:33 +03:00 · 2022-04-25 19:07:18 +03:00 · 2022-04-25 19:05:23 +03:00 · 2022-04-24 23:45:10 +03:00
230 changed files with 13624 additions and 9090 deletions
--- a/.assets/help-screen.png
+++ b/.assets/help-screen.png
--- a/.gitattributes
+++ b/.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
--- a/.github/FUNDING.yml
+++ b/.github/FUNDING.yml
@@ -1,3 +0,0 @@
-github: Tyrrrz
-patreon: Tyrrrz
-custom: ['buymeacoffee.com/Tyrrrz', 'tyrrrz.me/donate']
--- a/.github/ISSUE_TEMPLATE/bug-report.yml
+++ b/.github/ISSUE_TEMPLATE/bug-report.yml
@@ -0,0 +1,42 @@
+name: 🐞 Bug report
+description: Report broken functionality.
+labels: [bug]
+
+body:
+- type: markdown
+  attributes:
+    value: |
+      🧐 **Guidelines:**
+
+      - Search through [existing issues](https://github.com/Tyrrrz/CliFx/issues?q=is%3Aissue) first to ensure that this bug has not been reported before.
+      - Write a descriptive title for your issue. Avoid generic or vague titles such as "Something's not working" or "A couple of problems".
+      - Keep your issue focused on one single problem. If you have multiple bug reports, please create separate issues for each of them.
+      - Provide as much context as possible in the details section. Include screenshots, screen recordings, links, references, or anything else you may consider relevant.
+      - If you want to ask a question instead of reporting a bug, please use [discussions](https://github.com/Tyrrrz/CliFx/discussions/new) instead.
+
+- type: input
+  attributes:
+    label: Version
+    description: Which version of CliFx does this bug affect?
+    placeholder: ver X.Y.Z
+  validations:
+    required: true
+
+- type: textarea
+  attributes:
+    label: Details
+    description: Clear and thorough explanation of the bug.
+    placeholder: I was doing X expecting Y to happen, but Z happened instead.
+  validations:
+    required: true
+
+- type: textarea
+  attributes:
+    label: Steps to reproduce
+    description: Minimum steps required to reproduce the bug.
+    placeholder: |
+      - Step 1
+      - Step 2
+      - Step 3
+  validations:
+    required: true
--- a/.github/ISSUE_TEMPLATE/config.yml
+++ b/.github/ISSUE_TEMPLATE/config.yml
@@ -0,0 +1,8 @@
+blank_issues_enabled: false
+contact_links:
+  - name: 💬 Discord server
+    url: https://discord.gg/2SUWKFnHSm
+    about: Chat with the project community.
+  - name: 🗨 Discussions
+    url: https://github.com/Tyrrrz/CliFx/discussions/new
+    about: Ask and answer questions.
--- a/.github/ISSUE_TEMPLATE/feature-request.yml
+++ b/.github/ISSUE_TEMPLATE/feature-request.yml
@@ -0,0 +1,22 @@
+name: ✨ Feature request
+description: Request a new feature.
+labels: [enhancement]
+
+body:
+- type: markdown
+  attributes:
+    value: |
+      🧐 **Guidelines:**
+
+      - Search through [existing issues](https://github.com/Tyrrrz/CliFx/issues?q=is%3Aissue) first to ensure that this feature has not been requested before.
+      - Write a descriptive title for your issue. Avoid generic or vague titles such as "Some suggestions" or "Ideas for improvement".
+      - Keep your issue focused on one single problem. If you have multiple feature requests, please create separate issues for each of them.
+      - Provide as much context as possible in the details section. Include screenshots, screen recordings, links, references, or anything else you may consider relevant.
+      - If you want to ask a question instead of requesting a feature, please use [discussions](https://github.com/Tyrrrz/CliFx/discussions/new) instead.
+
+- type: textarea
+  attributes:
+    label: Details
+    description: Clear and thorough explanation of the feature you have in mind.
+  validations:
+    required: true
--- a/.github/workflows/CD.yml
+++ b/.github/workflows/CD.yml
@@ -1,25 +0,0 @@
-name: CD
-
-on:
-  push:
-    tags:
-    - '*'
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v2
-
-    - name: Install .NET Core
-      uses: actions/setup-dotnet@v1.4.0
-      with:
-        dotnet-version: 3.1.100
-
-    - name: Pack
-      run: dotnet pack CliFx --configuration Release
-
-    - name: Deploy
-      run: dotnet nuget push CliFx/bin/Release/*.nupkg -s nuget.org -k ${{ secrets.NUGET_TOKEN }}
--- a/.github/workflows/CI.yml
+++ b/.github/workflows/CI.yml
@@ -1,35 +0,0 @@
-name: CI
-
-on: [push, pull_request]
-
-jobs:
-  build:
-    runs-on: ${{ matrix.os }}
-
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v2
-
-    - name: Install .NET Core
-      uses: actions/setup-dotnet@v1.4.0
-      with:
-        dotnet-version: 3.1.100
-
-    - name: Build & test
-      run: dotnet test --configuration Release --logger GitHubActions
-
-    - name: Upload coverage
-      uses: codecov/codecov-action@v1.0.5
-      with:
-        token: ${{ secrets.CODECOV_TOKEN }}
-        file: CliFx.Tests/bin/Release/Coverage.xml
-
-    - name: Upload coverage (analyzers)
-      uses: codecov/codecov-action@v1.0.5
-      with:
-        token: ${{ secrets.CODECOV_TOKEN }}
-        file: CliFx.Analyzers.Tests/bin/Release/Coverage.xml
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -0,0 +1,13 @@
+name: main
+
+on: [push, pull_request]
+
+jobs:
+  main:
+    uses: Tyrrrz/.github/.github/workflows/nuget.yml@master
+    with:
+      dotnet-version: 6.0.x
+    secrets:
+      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+      NUGET_TOKEN: ${{ secrets.NUGET_TOKEN }}
+      DISCORD_WEBHOOK: ${{ secrets.DISCORD_WEBHOOK }}
--- a/.gitignore
+++ b/.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
--- a/.screenshots/help.png
+++ b/.screenshots/help.png
--- a/Changelog.md
+++ b/Changelog.md
@@ -1,3 +1,132 @@
+### v2.2.5 (10-May-2022)
+
+- Updated default value resolution for the application executable name. It will now resolve to `myapp.exe` instead of `dotnet myapp.dll` when the application is launched through the EXE apphost on Windows. On other platforms, or when running the application through the .NET CLI, the behavior will be the same as before.
+
+### v2.2.4 (22-Apr-2022)
+
+- Added more contextual information to analyzer diagnostics.
+- Fixed an issue where the analyzer incorrectly reported an error on converters that didn't directly match the target type but were compatible through known built-in conversions.
+- Fixed an issue where MSBuild produced a lot of analyzer-related warnings in certain circumstances.
+
+### v2.2.3 (17-Apr-2022)
+
+- Changed method signature of `IConsole.ReadKey()` to return `ConsoleKeyInfo` instead of `void`. The return type was originally defined as `void` by mistake. This change is source-backwards-compatible but may break on binary level if you were previously calling this method indirectly (i.e. through a library).
+- Added `FakeConsole.EnqueueKey(...)` to facilitate the testing of `IConsole.ReadKey()`. You can use this method to simulate key presses in your application.
+- Extended analyzers that verify the correctness of specified converters and validators. They now also ensure that the specified types are compatible with the type of the underlying property.
+- Improved diagnostics produced by analyzers. Where relevant, highlighted code is now limited to the property or type identifier, instead of the whole property or type declaration. Also extended the diagnostic messages with additional information.
+- Fixed an issue where throwing an exception inside a constructor of a command type resulted in an unrelated error message about the absence of a parameterless constructor.
+
+### v2.2.2 (30-Jan-2022)
+
+- Fixed an issue where `ConsoleWriter` and `ConsoleReader` were not properly thread-safe.
+- Fixed an issue where the analyzer failed to load under certain circumstances when running inside Visual Studio.
+
+### v2.2.1 (16-Jan-2022)
+
+- Fixed an issue which caused help text to not show default values for optional parameters. (Thanks [@AliReZa Sabouri](https://github.com/alirezanet))
+
+### v2.2 (11-Jan-2022)
+
+- Added support for optional parameters. A parameter can be marked as optional by setting `IsRequired = false` on the attribute. Only one parameter is allowed to be optional and such parameter must be the last in order. (Thanks [@AliReZa Sabouri](https://github.com/alirezanet))
+- Fixed an issue where parameters and options bound to properties implemented as default interface members were not working correctly. (Thanks [@AliReZa Sabouri](https://github.com/alirezanet))
+
+### v2.1 (04-Jan-2022)
+
+- Added `IConsole.Clear()` with corresponding implementations in `SystemConsole`, `FakeConsole`, and `FakeInMemoryConsole`. (Thanks [@Alex Rosenfeld](https://github.com/alexrosenfeld10))
+- Added `IConsole.ReadKey()` with corresponding implementations in `SystemConsole`, `FakeConsole`, and `FakeInMemoryConsole`. (Thanks [@Alex Rosenfeld](https://github.com/alexrosenfeld10))
+- Fixed an issue that caused parameters to appear out of order in the usage format section of the help text. (Thanks [@David Fallah](https://github.com/TAGC))
+
+### v2.0.6 (17-Jul-2021)
+
+- Fixed an issue where an exception thrown via reflection during parameter or option binding resulted in `Exception has been thrown by the target of an invocation` error instead of a more useful message. Such exceptions will now be unwrapped to provide better user experience.
+
+### v2.0.5 (09-Jul-2021)
+
+- Fixed an issue where calling `IConsole.Output.Encoding.EncodingName` and some other members threw an exception.
+- Added readme file to the package.
+
+### v2.0.4 (24-Apr-2021)
+
+- Fixed an issue where output and error streams in `SystemConsole` defaulted to UTF8 encoding with BOM when the application was running with UTF8 codepage. `ConsoleWriter` will now discard preamble from the specified encoding. This fix brings the behavior of `SystemConsole` in line with .NET's own `System.Console` which also discards preamble for output and error streams.
+- Fixed an issue where help text tried to show default values for parameters and options whose type does not override `ToString()` method.
+- Fixed an issue where help text didn't show default values for parameters and options whose type is an enumerable of nullable enums. (Thanks [@Robert Dailey](https://github.com/rcdailey))
+- Fixed an issue where specific parts of the help text weren't legible in some terminals due to low color resolution. Removed the usage of `ConsoleColor.DarkGray` in help text.
+
+### v2.0.3 (09-Apr-2021)
+
+- Improved help text by showing valid values for non-scalar enum parameters and options. (Thanks [@Robert Dailey](https://github.com/rcdailey))
+
+### v2.0.2 (31-Mar-2021)
+
+- Fixed an issue where having a transitive reference to CliFx sometimes resulted in `SystemConsoleShouldBeAvoidedAnalyzer` throwing `NullReferenceException` during build.
+- Fixed some documentation typos and inconsistencies.
+
+### 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.
--- a/CliFx.Analyzers.Tests/AnalyzerTestCase.cs
+++ b/CliFx.Analyzers.Tests/AnalyzerTestCase.cs
@@ -1,43 +0,0 @@
-using System.Collections.Generic;
-using System.Linq;
-using Microsoft.CodeAnalysis;
-
-namespace CliFx.Analyzers.Tests
-{
-    public class AnalyzerTestCase
-    {
-        public string Name { get; }
-
-        public IReadOnlyList<DiagnosticDescriptor> TestedDiagnostics { get; }
-
-        public IReadOnlyList<string> SourceCodes { get; }
-
-        public AnalyzerTestCase(
-            string name,
-            IReadOnlyList<DiagnosticDescriptor> testedDiagnostics,
-            IReadOnlyList<string> sourceCodes)
-        {
-            Name = name;
-            TestedDiagnostics = testedDiagnostics;
-            SourceCodes = sourceCodes;
-        }
-
-        public AnalyzerTestCase(
-            string name,
-            IReadOnlyList<DiagnosticDescriptor> testedDiagnostics,
-            string sourceCode)
-            : this(name, testedDiagnostics, new[] {sourceCode})
-        {
-        }
-
-        public AnalyzerTestCase(
-            string name,
-            DiagnosticDescriptor testedDiagnostic,
-            string sourceCode)
-            : this(name, new[] {testedDiagnostic}, sourceCode)
-        {
-        }
-
-        public override string ToString() => $"{Name} [{string.Join(", ", TestedDiagnostics.Select(d => d.Id))}]";
-    }
-}
--- a/CliFx.Analyzers.Tests/CliFx.Analyzers.Tests.csproj
+++ b/CliFx.Analyzers.Tests/CliFx.Analyzers.Tests.csproj
@@ -1,24 +1,22 @@
 <Project Sdk="Microsoft.NET.Sdk">
-  <Import Project="../CliFx.props" />

  <PropertyGroup>
-    <TargetFramework>netcoreapp3.1</TargetFramework>
-    <IsPackable>false</IsPackable>
-    <IsTestProject>true</IsTestProject>
-    <CollectCoverage>true</CollectCoverage>
-    <CoverletOutputFormat>opencover</CoverletOutputFormat>
-    <CoverletOutput>bin/$(Configuration)/Coverage.xml</CoverletOutput>
+    <TargetFramework>net6.0</TargetFramework>
  </PropertyGroup>

  <ItemGroup>
-    <PackageReference Include="Gu.Roslyn.Asserts" Version="3.3.0" />
-    <PackageReference Include="GitHubActionsTestLogger" Version="1.0.0" />
-    <PackageReference Include="FluentAssertions" Version="5.10.2" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.2.0" />
-    <PackageReference Include="xunit" Version="2.4.0" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.0" />
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="3.4.0" />
-    <PackageReference Include="coverlet.msbuild" Version="2.8.0" PrivateAssets="all" />
+    <Content Include="xunit.runner.json" CopyToOutputDirectory="PreserveNewest" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Basic.Reference.Assemblies" Version="1.2.4" />
+    <PackageReference Include="GitHubActionsTestLogger" Version="1.4.1" PrivateAssets="all" />
+    <PackageReference Include="FluentAssertions" Version="6.6.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.1.0" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.1.0" />
+    <PackageReference Include="xunit" Version="2.4.1" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5" PrivateAssets="all" />
+    <PackageReference Include="coverlet.collector" Version="3.1.2" PrivateAssets="all" />
  </ItemGroup>

  <ItemGroup>
--- a/CliFx.Analyzers.Tests/CommandMustBeAnnotatedAnalyzerSpecs.cs
+++ b/CliFx.Analyzers.Tests/CommandMustBeAnnotatedAnalyzerSpecs.cs
@@ -0,0 +1,71 @@
+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);
+    }
+}
--- a/CliFx.Analyzers.Tests/CommandMustImplementInterfaceAnalyzerSpecs.cs
+++ b/CliFx.Analyzers.Tests/CommandMustImplementInterfaceAnalyzerSpecs.cs
@@ -0,0 +1,57 @@
+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);
+    }
+}
--- a/CliFx.Analyzers.Tests/CommandSchemaAnalyzerTests.cs
+++ b/CliFx.Analyzers.Tests/CommandSchemaAnalyzerTests.cs
@@ -1,489 +0,0 @@
-using System.Collections.Generic;
-using CliFx.Analyzers.Tests.Internal;
-using Microsoft.CodeAnalysis.Diagnostics;
-using Xunit;
-
-namespace CliFx.Analyzers.Tests
-{
-    public class CommandSchemaAnalyzerTests
-    {
-        private static DiagnosticAnalyzer Analyzer { get; } = new CommandSchemaAnalyzer();
-
-        public static IEnumerable<object[]> GetValidCases()
-        {
-            yield return new object[]
-            {
-                new AnalyzerTestCase(
-                    "Non-command type",
-                    Analyzer.SupportedDiagnostics,
-
-                    // language=cs
-                    @"
-public class Foo
-{
-    public int Bar { get; set; } = 5;
-}"
-                )
-            };
-
-            yield return new object[]
-            {
-                new AnalyzerTestCase(
-                    "Command implements interface and has attribute",
-                    Analyzer.SupportedDiagnostics,
-
-                    // language=cs
-                    @"
-[Command]
-public class MyCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}"
-                )
-            };
-
-            yield return new object[]
-            {
-                new AnalyzerTestCase(
-                    "Command doesn't have an attribute but is an abstract type",
-                    Analyzer.SupportedDiagnostics,
-
-                    // language=cs
-                    @"
-public abstract class MyCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}"
-                )
-            };
-
-            yield return new object[]
-            {
-                new AnalyzerTestCase(
-                    "Parameters with unique order",
-                    Analyzer.SupportedDiagnostics,
-
-                    // language=cs
-                    @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandParameter(13)]
-    public string ParamA { get; set; }
-    
-    [CommandParameter(15)]
-    public string ParamB { get; set; }
-
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}"
-                )
-            };
-
-            yield return new object[]
-            {
-                new AnalyzerTestCase(
-                    "Parameters with unique names",
-                    Analyzer.SupportedDiagnostics,
-
-                    // language=cs
-                    @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandParameter(13, Name = ""foo"")]
-    public string ParamA { get; set; }
-    
-    [CommandParameter(15, Name = ""bar"")]
-    public string ParamB { get; set; }
-
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}"
-                )
-            };
-
-            yield return new object[]
-            {
-                new AnalyzerTestCase(
-                    "Single non-scalar parameter",
-                    Analyzer.SupportedDiagnostics,
-
-                    // language=cs
-                    @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandParameter(1)]
-    public string ParamA { get; set; }
-    
-    [CommandParameter(2)]
-    public HashSet<string> ParamB { get; set; }
-
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}"
-                )
-            };
-
-            yield return new object[]
-            {
-                new AnalyzerTestCase(
-                    "Non-scalar parameter is last in order",
-                    Analyzer.SupportedDiagnostics,
-
-                    // language=cs
-                    @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandParameter(1)]
-    public string ParamA { get; set; }
-    
-    [CommandParameter(2)]
-    public IReadOnlyList<string> ParamB { get; set; }
-
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}"
-                )
-            };
-
-            yield return new object[]
-            {
-                new AnalyzerTestCase(
-                    "Option with a proper name",
-                    Analyzer.SupportedDiagnostics,
-
-                    // language=cs
-                    @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption(""foo"")]
-    public string Param { get; set; }
-
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}"
-                )
-            };
-
-            yield return new object[]
-            {
-                new AnalyzerTestCase(
-                    "Option with a proper name and short name",
-                    Analyzer.SupportedDiagnostics,
-
-                    // language=cs
-                    @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption(""foo"", 'f')]
-    public string Param { get; set; }
-
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}"
-                )
-            };
-
-            yield return new object[]
-            {
-                new AnalyzerTestCase(
-                    "Options with unique names",
-                    Analyzer.SupportedDiagnostics,
-
-                    // language=cs
-                    @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption(""foo"")]
-    public string ParamA { get; set; }
-    
-    [CommandOption(""bar"")]
-    public string ParamB { get; set; }
-
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}"
-                )
-            };
-
-            yield return new object[]
-            {
-                new AnalyzerTestCase(
-                    "Options with unique short names",
-                    Analyzer.SupportedDiagnostics,
-
-                    // language=cs
-                    @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption('f')]
-    public string ParamA { get; set; }
-    
-    [CommandOption('x')]
-    public string ParamB { get; set; }
-
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}"
-                )
-            };
-
-            yield return new object[]
-            {
-                new AnalyzerTestCase(
-                    "Options with unique environment variable names",
-                    Analyzer.SupportedDiagnostics,
-
-                    // language=cs
-                    @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption('a', EnvironmentVariableName = ""env_var_a"")]
-    public string ParamA { get; set; }
-    
-    [CommandOption('b', EnvironmentVariableName = ""env_var_b"")]
-    public string ParamB { get; set; }
-
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}"
-                )
-            };
-        }
-
-        public static IEnumerable<object[]> GetInvalidCases()
-        {
-            yield return new object[]
-            {
-                new AnalyzerTestCase(
-                    "Command is missing the attribute",
-                    DiagnosticDescriptors.CliFx0002,
-
-                    // language=cs
-                    @"
-public class MyCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}"
-                )
-            };
-
-            yield return new object[]
-            {
-                new AnalyzerTestCase(
-                    "Command doesn't implement the interface",
-                    DiagnosticDescriptors.CliFx0001,
-
-                    // language=cs
-                    @"
-[Command]
-public class MyCommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}"
-                )
-            };
-
-            yield return new object[]
-            {
-                new AnalyzerTestCase(
-                    "Parameters with duplicate order",
-                    DiagnosticDescriptors.CliFx0021,
-
-                    // language=cs
-                    @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandParameter(13)]
-    public string ParamA { get; set; }
-    
-    [CommandParameter(13)]
-    public string ParamB { get; set; }
-
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}"
-                )
-            };
-
-            yield return new object[]
-            {
-                new AnalyzerTestCase(
-                    "Parameters with duplicate names",
-                    DiagnosticDescriptors.CliFx0022,
-
-                    // language=cs
-                    @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandParameter(13, Name = ""foo"")]
-    public string ParamA { get; set; }
-    
-    [CommandParameter(15, Name = ""foo"")]
-    public string ParamB { get; set; }
-
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}"
-                )
-            };
-
-            yield return new object[]
-            {
-                new AnalyzerTestCase(
-                    "Multiple non-scalar parameters",
-                    DiagnosticDescriptors.CliFx0023,
-
-                    // language=cs
-                    @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandParameter(1)]
-    public IReadOnlyList<string> ParamA { get; set; }
-    
-    [CommandParameter(2)]
-    public HashSet<string> ParamB { get; set; }
-
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}"
-                )
-            };
-
-            yield return new object[]
-            {
-                new AnalyzerTestCase(
-                    "Non-last non-scalar parameter",
-                    DiagnosticDescriptors.CliFx0024,
-
-                    // language=cs
-                    @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandParameter(1)]
-    public IReadOnlyList<string> ParamA { get; set; }
-    
-    [CommandParameter(2)]
-    public string ParamB { get; set; }
-
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}"
-                )
-            };
-
-            yield return new object[]
-            {
-                new AnalyzerTestCase(
-                    "Option with an empty name",
-                    DiagnosticDescriptors.CliFx0041,
-
-                    // language=cs
-                    @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption("""")]
-    public string Param { get; set; }
-
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}"
-                )
-            };
-
-            yield return new object[]
-            {
-                new AnalyzerTestCase(
-                    "Option with a name which is too short",
-                    DiagnosticDescriptors.CliFx0042,
-
-                    // language=cs
-                    @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption(""a"")]
-    public string Param { get; set; }
-
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}"
-                )
-            };
-
-            yield return new object[]
-            {
-                new AnalyzerTestCase(
-                    "Options with duplicate names",
-                    DiagnosticDescriptors.CliFx0043,
-
-                    // language=cs
-                    @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption(""foo"")]
-    public string ParamA { get; set; }
-    
-    [CommandOption(""foo"")]
-    public string ParamB { get; set; }
-
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}"
-                )
-            };
-
-            yield return new object[]
-            {
-                new AnalyzerTestCase(
-                    "Options with duplicate short names",
-                    DiagnosticDescriptors.CliFx0044,
-
-                    // language=cs
-                    @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption('f')]
-    public string ParamA { get; set; }
-    
-    [CommandOption('f')]
-    public string ParamB { get; set; }
-
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}"
-                )
-            };
-
-            yield return new object[]
-            {
-                new AnalyzerTestCase(
-                    "Options with duplicate environment variable names",
-                    DiagnosticDescriptors.CliFx0045,
-
-                    // language=cs
-                    @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption('a', EnvironmentVariableName = ""env_var"")]
-    public string ParamA { get; set; }
-    
-    [CommandOption('b', EnvironmentVariableName = ""env_var"")]
-    public string ParamB { get; set; }
-
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}"
-                )
-            };
-        }
-
-        [Theory]
-        [MemberData(nameof(GetValidCases))]
-        public void Valid(AnalyzerTestCase testCase) =>
-            Analyzer.Should().NotProduceDiagnostics(testCase);
-
-        [Theory]
-        [MemberData(nameof(GetInvalidCases))]
-        public void Invalid(AnalyzerTestCase testCase) =>
-            Analyzer.Should().ProduceDiagnostics(testCase);
-    }
-}
--- a/CliFx.Analyzers.Tests/ConsoleUsageAnalyzerTests.cs
+++ b/CliFx.Analyzers.Tests/ConsoleUsageAnalyzerTests.cs
@@ -1,144 +0,0 @@
-using System.Collections.Generic;
-using CliFx.Analyzers.Tests.Internal;
-using Microsoft.CodeAnalysis.Diagnostics;
-using Xunit;
-
-namespace CliFx.Analyzers.Tests
-{
-    public class ConsoleUsageAnalyzerTests
-    {
-        private static DiagnosticAnalyzer Analyzer { get; } = new ConsoleUsageAnalyzer();
-
-        public static IEnumerable<object[]> GetValidCases()
-        {
-            yield return new object[]
-            {
-                new AnalyzerTestCase(
-                    "Using console abstraction",
-                    Analyzer.SupportedDiagnostics,
-
-                    // language=cs
-                    @"
-[Command]
-public class MyCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""Hello world"");
-        return default;
-    }
-}"
-                )
-            };
-
-            yield return new object[]
-            {
-                new AnalyzerTestCase(
-                    "Console abstraction is not available in scope",
-                    Analyzer.SupportedDiagnostics,
-
-                    // language=cs
-                    @"
-[Command]
-public class MyCommand : ICommand
-{
-    public void SomeOtherMethod() => Console.WriteLine(""Test"");
-
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}"
-                )
-            };
-        }
-
-        public static IEnumerable<object[]> GetInvalidCases()
-        {
-            yield return new object[]
-            {
-                new AnalyzerTestCase(
-                    "Not using available console abstraction in the ExecuteAsync method",
-                    Analyzer.SupportedDiagnostics,
-
-                    // language=cs
-                    @"
-[Command]
-public class MyCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        Console.WriteLine(""Hello world"");
-        return default;
-    }
-}"
-                )
-            };
-
-            yield return new object[]
-            {
-                new AnalyzerTestCase(
-                    "Not using available console abstraction in the ExecuteAsync method when writing stderr",
-                    Analyzer.SupportedDiagnostics,
-
-                    // language=cs
-                    @"
-[Command]
-public class MyCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        Console.Error.WriteLine(""Hello world"");
-        return default;
-    }
-}"
-                )
-            };
-
-            yield return new object[]
-            {
-                new AnalyzerTestCase(
-                    "Not using available console abstraction while referencing System.Console by full name",
-                    Analyzer.SupportedDiagnostics,
-
-                    // language=cs
-                    @"
-[Command]
-public class MyCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        System.Console.Error.WriteLine(""Hello world"");
-        return default;
-    }
-}"
-                )
-            };
-
-            yield return new object[]
-            {
-                new AnalyzerTestCase(
-                    "Not using available console abstraction in another method",
-                    DiagnosticDescriptors.CliFx0100,
-
-                    // language=cs
-                    @"
-[Command]
-public class MyCommand : ICommand
-{
-    public void SomeOtherMethod(IConsole console) => Console.WriteLine(""Test"");
-
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}"
-                )
-            };
-        }
-
-        [Theory]
-        [MemberData(nameof(GetValidCases))]
-        public void Valid(AnalyzerTestCase testCase) =>
-            Analyzer.Should().NotProduceDiagnostics(testCase);
-
-        [Theory]
-        [MemberData(nameof(GetInvalidCases))]
-        public void Invalid(AnalyzerTestCase testCase) =>
-            Analyzer.Should().ProduceDiagnostics(testCase);
-    }
-}
--- a/CliFx.Analyzers.Tests/GeneralSpecs.cs
+++ b/CliFx.Analyzers.Tests/GeneralSpecs.cs
@@ -0,0 +1,30 @@
+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();
+    }
+}
--- a/CliFx.Analyzers.Tests/Internal/AnalyzerAssertions.cs
+++ b/CliFx.Analyzers.Tests/Internal/AnalyzerAssertions.cs
@@ -1,107 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using FluentAssertions.Execution;
-using FluentAssertions.Primitives;
-using Gu.Roslyn.Asserts;
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CodeAnalysis.Diagnostics;
-
-namespace CliFx.Analyzers.Tests.Internal
-{
-    internal partial class AnalyzerAssertions : ReferenceTypeAssertions<DiagnosticAnalyzer, AnalyzerAssertions>
-    {
-        protected override string Identifier { get; } = "analyzer";
-
-        public AnalyzerAssertions(DiagnosticAnalyzer analyzer)
-            : base(analyzer)
-        {
-        }
-
-        public void ProduceDiagnostics(
-            IReadOnlyList<DiagnosticDescriptor> diagnostics,
-            IReadOnlyList<string> sourceCodes)
-        {
-            var producedDiagnostics = GetProducedDiagnostics(Subject, sourceCodes);
-
-            var expectedIds = diagnostics.Select(d => d.Id).Distinct().OrderBy(d => d).ToArray();
-            var producedIds = producedDiagnostics.Select(d => d.Id).Distinct().OrderBy(d => d).ToArray();
-
-            var result = expectedIds.Intersect(producedIds).Count() == expectedIds.Length;
-
-            Execute.Assertion.ForCondition(result).FailWith($@"
-Expected and produced diagnostics do not match.
-
-Expected: {string.Join(", ", expectedIds)}
-Produced: {(producedIds.Any() ? string.Join(", ", producedIds) : "<none>")}
-".Trim());
-        }
-
-        public void ProduceDiagnostics(AnalyzerTestCase testCase) =>
-            ProduceDiagnostics(testCase.TestedDiagnostics, testCase.SourceCodes);
-
-        public void NotProduceDiagnostics(
-            IReadOnlyList<DiagnosticDescriptor> diagnostics,
-            IReadOnlyList<string> sourceCodes)
-        {
-            var producedDiagnostics = GetProducedDiagnostics(Subject, sourceCodes);
-
-            var expectedIds = diagnostics.Select(d => d.Id).Distinct().OrderBy(d => d).ToArray();
-            var producedIds = producedDiagnostics.Select(d => d.Id).Distinct().OrderBy(d => d).ToArray();
-
-            var result = !expectedIds.Intersect(producedIds).Any();
-
-            Execute.Assertion.ForCondition(result).FailWith($@"
-Expected no produced diagnostics.
-
-Produced: {string.Join(", ", producedIds)}
-".Trim());
-        }
-
-        public void NotProduceDiagnostics(AnalyzerTestCase testCase) =>
-            NotProduceDiagnostics(testCase.TestedDiagnostics, testCase.SourceCodes);
-    }
-
-    internal partial class AnalyzerAssertions
-    {
-        private static IReadOnlyList<MetadataReference> DefaultMetadataReferences { get; } =
-            MetadataReferences.Transitive(typeof(CliApplication).Assembly).ToArray();
-
-        private static string WrapCodeWithUsingDirectives(string code)
-        {
-            var usingDirectives = new[]
-            {
-                "using System;",
-                "using System.Collections.Generic;",
-                "using System.Threading.Tasks;",
-                "using CliFx;",
-                "using CliFx.Attributes;",
-                "using CliFx.Exceptions;",
-                "using CliFx.Utilities;"
-            };
-
-            return
-                string.Join(Environment.NewLine, usingDirectives) +
-                Environment.NewLine +
-                code;
-        }
-
-        private static IReadOnlyList<Diagnostic> GetProducedDiagnostics(
-            DiagnosticAnalyzer analyzer,
-            IReadOnlyList<string> sourceCodes)
-        {
-            var compilationOptions = new CSharpCompilationOptions(OutputKind.ConsoleApplication);
-            var wrappedSourceCodes = sourceCodes.Select(WrapCodeWithUsingDirectives).ToArray();
-
-            return Analyze.GetDiagnostics(analyzer, wrappedSourceCodes, compilationOptions, DefaultMetadataReferences)
-                .SelectMany(d => d)
-                .ToArray();
-        }
-    }
-
-    internal static class AnalyzerAssertionsExtensions
-    {
-        public static AnalyzerAssertions Should(this DiagnosticAnalyzer analyzer) => new AnalyzerAssertions(analyzer);
-    }
-}
--- a/CliFx.Analyzers.Tests/OptionMustBeInsideCommandAnalyzerSpecs.cs
+++ b/CliFx.Analyzers.Tests/OptionMustBeInsideCommandAnalyzerSpecs.cs
@@ -0,0 +1,79 @@
+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);
+    }
+}
--- a/CliFx.Analyzers.Tests/OptionMustHaveNameOrShortNameAnalyzerSpecs.cs
+++ b/CliFx.Analyzers.Tests/OptionMustHaveNameOrShortNameAnalyzerSpecs.cs
@@ -0,0 +1,85 @@
+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);
+    }
+}
--- a/CliFx.Analyzers.Tests/OptionMustHaveUniqueNameAnalyzerSpecs.cs
+++ b/CliFx.Analyzers.Tests/OptionMustHaveUniqueNameAnalyzerSpecs.cs
@@ -0,0 +1,91 @@
+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);
+    }
+}
--- a/CliFx.Analyzers.Tests/OptionMustHaveUniqueShortNameAnalyzerSpecs.cs
+++ b/CliFx.Analyzers.Tests/OptionMustHaveUniqueShortNameAnalyzerSpecs.cs
@@ -0,0 +1,113 @@
+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);
+    }
+}
--- a/CliFx.Analyzers.Tests/OptionMustHaveValidConverterAnalyzerSpecs.cs
+++ b/CliFx.Analyzers.Tests/OptionMustHaveValidConverterAnalyzerSpecs.cs
@@ -0,0 +1,167 @@
+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_an_option_has_a_converter_that_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_reports_an_error_if_an_option_has_a_converter_that_does_not_derive_from_a_compatible_BindingConverter()
+    {
+        // Arrange
+        // language=cs
+        const string code = @"
+public class MyConverter : BindingConverter<int>
+{
+    public override int Convert(string rawValue) => 42;
+}
+
+[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_an_option_has_a_converter_that_derives_from_a_compatible_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_a_nullable_option_has_a_converter_that_derives_from_a_compatible_BindingConverter()
+    {
+        // Arrange
+        // language=cs
+        const string code = @"
+public class MyConverter : BindingConverter<int>
+{
+    public override int Convert(string rawValue) => 42;
+}
+
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandOption(""foo"", Converter = typeof(MyConverter))]
+    public int? 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_non_scalar_option_has_a_converter_that_derives_from_a_compatible_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 IReadOnlyList<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);
+    }
+}
--- a/CliFx.Analyzers.Tests/OptionMustHaveValidNameAnalyzerSpecs.cs
+++ b/CliFx.Analyzers.Tests/OptionMustHaveValidNameAnalyzerSpecs.cs
@@ -0,0 +1,104 @@
+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);
+    }
+}
--- a/CliFx.Analyzers.Tests/OptionMustHaveValidShortNameAnalyzerSpecs.cs
+++ b/CliFx.Analyzers.Tests/OptionMustHaveValidShortNameAnalyzerSpecs.cs
@@ -0,0 +1,85 @@
+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);
+    }
+}
--- a/CliFx.Analyzers.Tests/OptionMustHaveValidValidatorsAnalyzerSpecs.cs
+++ b/CliFx.Analyzers.Tests/OptionMustHaveValidValidatorsAnalyzerSpecs.cs
@@ -0,0 +1,119 @@
+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_an_option_has_a_validator_that_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_reports_an_error_if_an_option_has_a_validator_that_does_not_derive_from_a_compatible_BindingValidator()
+    {
+        // Arrange
+        // language=cs
+        const string code = @"
+public class MyValidator : BindingValidator<int>
+{
+    public override BindingValidationError Validate(int 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().ProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_an_option_has_validators_that_all_derive_from_compatible_BindingValidators()
+    {
+        // 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);
+    }
+}
--- a/CliFx.Analyzers.Tests/ParameterMustBeInsideCommandAnalyzerSpecs.cs
+++ b/CliFx.Analyzers.Tests/ParameterMustBeInsideCommandAnalyzerSpecs.cs
@@ -0,0 +1,79 @@
+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);
+    }
+}
--- a/CliFx.Analyzers.Tests/ParameterMustBeLastIfNonRequiredAnalyzerSpecs.cs
+++ b/CliFx.Analyzers.Tests/ParameterMustBeLastIfNonRequiredAnalyzerSpecs.cs
@@ -0,0 +1,94 @@
+using CliFx.Analyzers.Tests.Utils;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Xunit;
+
+namespace CliFx.Analyzers.Tests;
+
+public class ParameterMustBeLastIfNonRequiredAnalyzerSpecs
+{
+    private static DiagnosticAnalyzer Analyzer { get; } = new ParameterMustBeLastIfNonRequiredAnalyzer();
+
+    [Fact]
+    public void Analyzer_reports_an_error_if_a_non_required_parameter_is_not_the_last_in_order()
+    {
+        // Arrange
+        // language=cs
+        const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandParameter(0, Name = ""foo"", IsRequired = false)]
+    public string Foo { get; set; }
+
+    [CommandParameter(1, Name = ""bar"")]
+    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_required_parameter_is_the_last_in_order()
+    {
+        // Arrange
+        // language=cs
+        const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandParameter(0, Name = ""foo"")]
+    public string Foo { get; set; }
+
+    [CommandParameter(1, Name = ""bar"", IsRequired = false)]
+    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_required_parameters_are_defined()
+    {
+        // Arrange
+        // language=cs
+        const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandParameter(0, Name = ""foo"")]
+    public string Foo { get; set; }
+
+    [CommandParameter(1, Name = ""bar"", IsRequired = true)]
+    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);
+    }
+}
--- a/CliFx.Analyzers.Tests/ParameterMustBeLastIfNonScalarAnalyzerSpecs.cs
+++ b/CliFx.Analyzers.Tests/ParameterMustBeLastIfNonScalarAnalyzerSpecs.cs
@@ -0,0 +1,94 @@
+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_the_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_the_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);
+    }
+}
--- a/CliFx.Analyzers.Tests/ParameterMustBeSingleIfNonRequiredAnalyzerSpecs.cs
+++ b/CliFx.Analyzers.Tests/ParameterMustBeSingleIfNonRequiredAnalyzerSpecs.cs
@@ -0,0 +1,94 @@
+using CliFx.Analyzers.Tests.Utils;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Xunit;
+
+namespace CliFx.Analyzers.Tests;
+
+public class ParameterMustBeSingleIfNonRequiredAnalyzerSpecs
+{
+    private static DiagnosticAnalyzer Analyzer { get; } = new ParameterMustBeSingleIfNonRequiredAnalyzer();
+
+    [Fact]
+    public void Analyzer_reports_an_error_if_more_than_one_non_required_parameters_are_defined()
+    {
+        // Arrange
+        // language=cs
+        const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandParameter(0, IsRequired = false)]
+    public string Foo { get; set; }
+
+    [CommandParameter(1, IsRequired = false)]
+    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_required_parameter_is_defined()
+    {
+        // Arrange
+        // language=cs
+        const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandParameter(0)]
+    public string Foo { get; set; }
+
+    [CommandParameter(1, IsRequired = false)]
+    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_required_parameters_are_defined()
+    {
+        // Arrange
+        // language=cs
+        const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandParameter(0)]
+    public string Foo { get; set; }
+
+    [CommandParameter(1, IsRequired = true)]
+    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);
+    }
+}
--- a/CliFx.Analyzers.Tests/ParameterMustBeSingleIfNonScalarAnalyzerSpecs.cs
+++ b/CliFx.Analyzers.Tests/ParameterMustBeSingleIfNonScalarAnalyzerSpecs.cs
@@ -0,0 +1,94 @@
+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);
+    }
+}
--- a/CliFx.Analyzers.Tests/ParameterMustHaveUniqueNameAnalyzerSpecs.cs
+++ b/CliFx.Analyzers.Tests/ParameterMustHaveUniqueNameAnalyzerSpecs.cs
@@ -0,0 +1,72 @@
+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);
+    }
+}
--- a/CliFx.Analyzers.Tests/ParameterMustHaveUniqueOrderAnalyzerSpecs.cs
+++ b/CliFx.Analyzers.Tests/ParameterMustHaveUniqueOrderAnalyzerSpecs.cs
@@ -0,0 +1,72 @@
+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);
+    }
+}
--- a/CliFx.Analyzers.Tests/ParameterMustHaveValidConverterAnalyzerSpecs.cs
+++ b/CliFx.Analyzers.Tests/ParameterMustHaveValidConverterAnalyzerSpecs.cs
@@ -0,0 +1,168 @@
+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_a_parameter_has_a_converter_that_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_reports_an_error_if_a_parameter_has_a_converter_that_does_not_derive_from_a_compatible_BindingConverter()
+    {
+        // Arrange
+        // language=cs
+        const string code = @"
+public class MyConverter : BindingConverter<int>
+{
+    public override int Convert(string rawValue) => 42;
+}
+
+[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_a_parameter_has_a_converter_that_derives_from_a_compatible_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_nullable_parameter_has_a_converter_that_derives_from_a_compatible_BindingConverter()
+    {
+        // Arrange
+        // language=cs
+        const string code = @"
+public class MyConverter : BindingConverter<int>
+{
+    public override int Convert(string rawValue) => 42;
+}
+
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandOption(""foo"", Converter = typeof(MyConverter))]
+    public int? 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_non_scalar_parameter_has_a_converter_that_derives_from_a_compatible_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 IReadOnlyList<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);
+    }
+}
--- a/CliFx.Analyzers.Tests/ParameterMustHaveValidValidatorsAnalyzerSpecs.cs
+++ b/CliFx.Analyzers.Tests/ParameterMustHaveValidValidatorsAnalyzerSpecs.cs
@@ -0,0 +1,119 @@
+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_a_parameter_has_a_validator_that_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_reports_an_error_if_a_parameter_has_a_validator_that_does_not_derive_from_a_compatible_BindingValidator()
+    {
+        // Arrange
+        // language=cs
+        const string code = @"
+public class MyValidator : BindingValidator<int>
+{
+    public override BindingValidationError Validate(int 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().ProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_parameter_has_validators_that_all_derive_from_compatible_BindingValidators()
+    {
+        // 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);
+    }
+}
--- a/CliFx.Analyzers.Tests/SystemConsoleShouldBeAvoidedAnalyzerSpecs.cs
+++ b/CliFx.Analyzers.Tests/SystemConsoleShouldBeAvoidedAnalyzerSpecs.cs
@@ -0,0 +1,126 @@
+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);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_command_does_not_access_SystemConsole()
+    {
+        // Arrange
+        // language=cs
+        const string code = @"
+[Command]
+public class MyCommand : ICommand
+{
+    public ValueTask ExecuteAsync(IConsole console)
+    {
+        return default;
+    }
+}";
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+}
--- a/CliFx.Analyzers.Tests/Utils/AnalyzerAssertions.cs
+++ b/CliFx.Analyzers.Tests/Utils/AnalyzerAssertions.cs
@@ -0,0 +1,173 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
+using System.Text;
+using Basic.Reference.Assemblies;
+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 },
+            ReferenceAssemblies.Net50
+                .Append(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 isSuccessfulAssertion =
+            expectedDiagnosticIds.Intersect(producedDiagnosticIds).Count() ==
+            expectedDiagnosticIds.Length;
+
+        Execute.Assertion.ForCondition(isSuccessfulAssertion).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:");
+
+            if (producedDiagnostics.Any())
+            {
+                foreach (var producedDiagnostic in producedDiagnostics)
+                {
+                    buffer.Append("  - ");
+                    buffer.Append(producedDiagnostic);
+                }
+            }
+            else
+            {
+                buffer.AppendLine("  < none >");
+            }
+
+            return new FailReason(buffer.ToString());
+        });
+    }
+
+    public void NotProduceDiagnostics(string sourceCode)
+    {
+        var producedDiagnostics = GetProducedDiagnostics(sourceCode);
+        var isSuccessfulAssertion = !producedDiagnostics.Any();
+
+        Execute.Assertion.ForCondition(isSuccessfulAssertion).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);
+}
--- a/CliFx.Analyzers.Tests/xunit.runner.json
+++ b/CliFx.Analyzers.Tests/xunit.runner.json
@@ -0,0 +1,5 @@
+{
+  "$schema": "https://xunit.net/schema/current/xunit.runner.schema.json",
+  "methodDisplayOptions": "all",
+  "methodDisplay": "method"
+}
--- a/CliFx.Analyzers/AnalyzerBase.cs
+++ b/CliFx.Analyzers/AnalyzerBase.cs
@@ -0,0 +1,39 @@
+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, params object?[]? messageArgs) =>
+        Diagnostic.Create(SupportedDiagnostic, location, messageArgs);
+
+    public override void Initialize(AnalysisContext context)
+    {
+        context.EnableConcurrentExecution();
+        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+    }
+}
--- a/CliFx.Analyzers/CliFx.Analyzers.csproj
+++ b/CliFx.Analyzers/CliFx.Analyzers.csproj
@@ -1,13 +1,16 @@
 <Project Sdk="Microsoft.NET.Sdk">
-  <Import Project="../CliFx.props" />

  <PropertyGroup>
    <TargetFramework>netstandard2.0</TargetFramework>
+    <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
    <Nullable>annotations</Nullable>
+    <NoWarn>$(NoWarn);RS1025;RS1026</NoWarn>
  </PropertyGroup>

  <ItemGroup>
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="3.4.0" PrivateAssets="all" />
+    <!-- Keep this dependency as low as possible since we can't bundle it -->
+    <!-- https://github.com/Tyrrrz/CliFx/issues/127 -->
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="3.8.0" PrivateAssets="all" />
  </ItemGroup>

 </Project>
--- a/CliFx.Analyzers/CommandMustBeAnnotatedAnalyzer.cs
+++ b/CliFx.Analyzers/CommandMustBeAnnotatedAnalyzer.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 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(i => i.DisplayNameMatches(SymbolNames.CliFxCommandInterface));
+
+        var hasCommandAttribute = type
+            .GetAttributes()
+            .Select(a => a.AttributeClass)
+            .Any(c => c.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.Identifier.GetLocation())
+            );
+        }
+    }
+
+    public override void Initialize(AnalysisContext context)
+    {
+        base.Initialize(context);
+        context.HandleClassDeclaration(Analyze);
+    }
+}
--- a/CliFx.Analyzers/CommandMustImplementInterfaceAnalyzer.cs
+++ b/CliFx.Analyzers/CommandMustImplementInterfaceAnalyzer.cs
@@ -0,0 +1,49 @@
+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(c => c.DisplayNameMatches(SymbolNames.CliFxCommandAttribute));
+
+        var implementsCommandInterface = type
+            .AllInterfaces
+            .Any(i => i.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.Identifier.GetLocation())
+            );
+        }
+    }
+
+    public override void Initialize(AnalysisContext context)
+    {
+        base.Initialize(context);
+        context.HandleClassDeclaration(Analyze);
+    }
+}
--- a/CliFx.Analyzers/CommandSchemaAnalyzer.cs
+++ b/CliFx.Analyzers/CommandSchemaAnalyzer.cs
@@ -1,297 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Collections.Immutable;
-using System.Linq;
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.Diagnostics;
-
-namespace CliFx.Analyzers
-{
-    [DiagnosticAnalyzer(LanguageNames.CSharp)]
-    public class CommandSchemaAnalyzer : DiagnosticAnalyzer
-    {
-        public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(
-            DiagnosticDescriptors.CliFx0001,
-            DiagnosticDescriptors.CliFx0002,
-            DiagnosticDescriptors.CliFx0021,
-            DiagnosticDescriptors.CliFx0022,
-            DiagnosticDescriptors.CliFx0023,
-            DiagnosticDescriptors.CliFx0024,
-            DiagnosticDescriptors.CliFx0041,
-            DiagnosticDescriptors.CliFx0042,
-            DiagnosticDescriptors.CliFx0043,
-            DiagnosticDescriptors.CliFx0044,
-            DiagnosticDescriptors.CliFx0045
-        );
-
-        private static bool IsScalarType(ITypeSymbol typeSymbol) =>
-            KnownSymbols.IsSystemString(typeSymbol) ||
-            !typeSymbol.AllInterfaces.Select(i => i.ConstructedFrom).Any(KnownSymbols.IsSystemCollectionsGenericIEnumerable);
-
-        private static void CheckCommandParameterProperties(
-            SymbolAnalysisContext context,
-            IReadOnlyList<IPropertySymbol> properties)
-        {
-            var parameters = properties
-                .Select(p =>
-                {
-                    var attribute = p
-                        .GetAttributes()
-                        .First(a => KnownSymbols.IsCommandParameterAttribute(a.AttributeClass));
-
-                    var order = attribute
-                        .ConstructorArguments
-                        .Select(a => a.Value)
-                        .FirstOrDefault() as int?;
-
-                    var name = attribute
-                        .NamedArguments
-                        .Where(a => a.Key == "Name")
-                        .Select(a => a.Value.Value)
-                        .FirstOrDefault() as string;
-
-                    return new
-                    {
-                        Property = p,
-                        Order = order,
-                        Name = name
-                    };
-                })
-                .ToArray();
-
-            // Duplicate order
-            var duplicateOrderParameters = parameters
-                .Where(p => p.Order != null)
-                .GroupBy(p => p.Order)
-                .Where(g => g.Count() > 1)
-                .SelectMany(g => g.AsEnumerable())
-                .ToArray();
-
-            foreach (var parameter in duplicateOrderParameters)
-            {
-                context.ReportDiagnostic(
-                    Diagnostic.Create(DiagnosticDescriptors.CliFx0021, parameter.Property.Locations.First()));
-            }
-
-            // Duplicate name
-            var duplicateNameParameters = parameters
-                .Where(p => !string.IsNullOrWhiteSpace(p.Name))
-                .GroupBy(p => p.Name, StringComparer.OrdinalIgnoreCase)
-                .Where(g => g.Count() > 1)
-                .SelectMany(g => g.AsEnumerable())
-                .ToArray();
-
-            foreach (var parameter in duplicateNameParameters)
-            {
-                context.ReportDiagnostic(
-                    Diagnostic.Create(DiagnosticDescriptors.CliFx0022, parameter.Property.Locations.First()));
-            }
-
-            // Multiple non-scalar
-            var nonScalarParameters = parameters
-                .Where(p => !IsScalarType(p.Property.Type))
-                .ToArray();
-
-            if (nonScalarParameters.Length > 1)
-            {
-                foreach (var parameter in nonScalarParameters)
-                {
-                    context.ReportDiagnostic(
-                        Diagnostic.Create(DiagnosticDescriptors.CliFx0023, parameter.Property.Locations.First()));
-                }
-            }
-
-            // Non-last non-scalar
-            var nonLastNonScalarParameter = parameters
-                .OrderByDescending(a => a.Order)
-                .Skip(1)
-                .LastOrDefault(p => !IsScalarType(p.Property.Type));
-
-            if (nonLastNonScalarParameter != null)
-            {
-                context.ReportDiagnostic(
-                    Diagnostic.Create(DiagnosticDescriptors.CliFx0024, nonLastNonScalarParameter.Property.Locations.First()));
-            }
-        }
-
-        private static void CheckCommandOptionProperties(
-            SymbolAnalysisContext context,
-            IReadOnlyList<IPropertySymbol> properties)
-        {
-            var options = properties
-                .Select(p =>
-                {
-                    var attribute = p
-                        .GetAttributes()
-                        .First(a => KnownSymbols.IsCommandOptionAttribute(a.AttributeClass));
-
-                    var name = attribute
-                        .ConstructorArguments
-                        .Where(a => KnownSymbols.IsSystemString(a.Type))
-                        .Select(a => a.Value)
-                        .FirstOrDefault() as string;
-
-                    var shortName = attribute
-                        .ConstructorArguments
-                        .Where(a => KnownSymbols.IsSystemChar(a.Type))
-                        .Select(a => a.Value)
-                        .FirstOrDefault() as char?;
-
-                    var envVarName = attribute
-                        .NamedArguments
-                        .Where(a => a.Key == "EnvironmentVariableName")
-                        .Select(a => a.Value.Value)
-                        .FirstOrDefault() as string;
-
-                    return new
-                    {
-                        Property = p,
-                        Name = name,
-                        ShortName = shortName,
-                        EnvironmentVariableName = envVarName
-                    };
-                })
-                .ToArray();
-
-            // No name
-            var noNameOptions = options
-                .Where(o => string.IsNullOrWhiteSpace(o.Name) && o.ShortName == null)
-                .ToArray();
-
-            foreach (var option in noNameOptions)
-            {
-                context.ReportDiagnostic(
-                    Diagnostic.Create(DiagnosticDescriptors.CliFx0041, option.Property.Locations.First()));
-            }
-
-            // Too short name
-            var invalidNameLengthOptions = options
-                .Where(o => !string.IsNullOrWhiteSpace(o.Name) && o.Name.Length <= 1)
-                .ToArray();
-
-            foreach (var option in invalidNameLengthOptions)
-            {
-                context.ReportDiagnostic(
-                    Diagnostic.Create(DiagnosticDescriptors.CliFx0042, option.Property.Locations.First()));
-            }
-
-            // Duplicate name
-            var duplicateNameOptions = options
-                .Where(p => !string.IsNullOrWhiteSpace(p.Name))
-                .GroupBy(p => p.Name, StringComparer.OrdinalIgnoreCase)
-                .Where(g => g.Count() > 1)
-                .SelectMany(g => g.AsEnumerable())
-                .ToArray();
-
-            foreach (var option in duplicateNameOptions)
-            {
-                context.ReportDiagnostic(
-                    Diagnostic.Create(DiagnosticDescriptors.CliFx0043, option.Property.Locations.First()));
-            }
-
-            // Duplicate name
-            var duplicateShortNameOptions = options
-                .Where(p => p.ShortName != null)
-                .GroupBy(p => p.ShortName)
-                .Where(g => g.Count() > 1)
-                .SelectMany(g => g.AsEnumerable())
-                .ToArray();
-
-            foreach (var option in duplicateShortNameOptions)
-            {
-                context.ReportDiagnostic(
-                    Diagnostic.Create(DiagnosticDescriptors.CliFx0044, option.Property.Locations.First()));
-            }
-
-            // Duplicate environment variable name
-            var duplicateEnvironmentVariableNameOptions = options
-                .Where(p => !string.IsNullOrWhiteSpace(p.EnvironmentVariableName))
-                .GroupBy(p => p.EnvironmentVariableName, StringComparer.OrdinalIgnoreCase)
-                .Where(g => g.Count() > 1)
-                .SelectMany(g => g.AsEnumerable())
-                .ToArray();
-
-            foreach (var option in duplicateEnvironmentVariableNameOptions)
-            {
-                context.ReportDiagnostic(
-                    Diagnostic.Create(DiagnosticDescriptors.CliFx0045, option.Property.Locations.First()));
-            }
-        }
-
-        private static void CheckCommandType(SymbolAnalysisContext context)
-        {
-            // Named type: MyCommand
-            if (!(context.Symbol is INamedTypeSymbol namedTypeSymbol))
-                return;
-
-            // Only classes
-            if (namedTypeSymbol.TypeKind != TypeKind.Class)
-                return;
-
-            // Implements ICommand?
-            var implementsCommandInterface = namedTypeSymbol
-                .AllInterfaces
-                .Any(KnownSymbols.IsCommandInterface);
-
-            // Has CommandAttribute?
-            var hasCommandAttribute = namedTypeSymbol
-                .GetAttributes()
-                .Select(a => a.AttributeClass)
-                .Any(KnownSymbols.IsCommandAttribute);
-
-            var isValidCommandType =
-                // implements interface
-                implementsCommandInterface && (
-                    // and either abstract class or has attribute
-                    namedTypeSymbol.IsAbstract || hasCommandAttribute
-                );
-
-            if (!isValidCommandType)
-            {
-                // See if this was meant to be a command type (either interface or attribute present)
-                var isAlmostValidCommandType = implementsCommandInterface ^ hasCommandAttribute;
-
-                if (isAlmostValidCommandType && !implementsCommandInterface)
-                    context.ReportDiagnostic(Diagnostic.Create(DiagnosticDescriptors.CliFx0001, namedTypeSymbol.Locations.First()));
-
-                if (isAlmostValidCommandType && !hasCommandAttribute)
-                    context.ReportDiagnostic(Diagnostic.Create(DiagnosticDescriptors.CliFx0002, namedTypeSymbol.Locations.First()));
-
-                return;
-            }
-
-            var properties = namedTypeSymbol
-                .GetMembers()
-                .Where(m => m.Kind == SymbolKind.Property)
-                .OfType<IPropertySymbol>().ToArray();
-
-            // Check parameters
-            var parameterProperties = properties
-                .Where(p => p
-                    .GetAttributes()
-                    .Select(a => a.AttributeClass)
-                    .Any(KnownSymbols.IsCommandParameterAttribute))
-                .ToArray();
-
-            CheckCommandParameterProperties(context, parameterProperties);
-
-            // Check options
-            var optionsProperties = properties
-                .Where(p => p
-                    .GetAttributes()
-                    .Select(a => a.AttributeClass)
-                    .Any(KnownSymbols.IsCommandOptionAttribute))
-                .ToArray();
-
-            CheckCommandOptionProperties(context, optionsProperties);
-        }
-
-        public override void Initialize(AnalysisContext context)
-        {
-            context.EnableConcurrentExecution();
-            context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
-
-            context.RegisterSymbolAction(CheckCommandType, SymbolKind.NamedType);
-        }
-    }
-}
--- a/CliFx.Analyzers/ConsoleUsageAnalyzer.cs
+++ b/CliFx.Analyzers/ConsoleUsageAnalyzer.cs
@@ -1,80 +0,0 @@
-using System.Collections.Immutable;
-using System.Linq;
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.Diagnostics;
-
-namespace CliFx.Analyzers
-{
-    [DiagnosticAnalyzer(LanguageNames.CSharp)]
-    public class ConsoleUsageAnalyzer : DiagnosticAnalyzer
-    {
-        public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(
-            DiagnosticDescriptors.CliFx0100
-        );
-
-        private static bool IsSystemConsoleInvocation(
-            SyntaxNodeAnalysisContext context,
-            InvocationExpressionSyntax invocationSyntax)
-        {
-            // Get the method member access (Console.WriteLine or Console.Error.WriteLine)
-            if (!(invocationSyntax.Expression is MemberAccessExpressionSyntax memberAccessSyntax))
-                return false;
-
-            // Get the semantic model for the invoked method
-            if (!(context.SemanticModel.GetSymbolInfo(memberAccessSyntax).Symbol is IMethodSymbol methodSymbol))
-                return false;
-
-            // Check if contained within System.Console
-            if (KnownSymbols.IsSystemConsole(methodSymbol.ContainingType))
-                return true;
-
-            // In case with Console.Error.WriteLine that wouldn't work, we need to check parent member access too
-            if (!(memberAccessSyntax.Expression is MemberAccessExpressionSyntax parentMemberAccessSyntax))
-                return false;
-
-            // Get the semantic model for the parent member
-            if (!(context.SemanticModel.GetSymbolInfo(parentMemberAccessSyntax).Symbol is IPropertySymbol propertySymbol))
-                return false;
-
-            // Check if contained within System.Console
-            if (KnownSymbols.IsSystemConsole(propertySymbol.ContainingType))
-                return true;
-
-            return false;
-        }
-
-        private static void CheckSystemConsoleUsage(SyntaxNodeAnalysisContext context)
-        {
-            if (!(context.Node is InvocationExpressionSyntax invocationSyntax))
-                return;
-
-            if (!IsSystemConsoleInvocation(context, invocationSyntax))
-                return;
-
-            // Check if IConsole is available in the scope as a viable alternative
-            var isConsoleInterfaceAvailable = invocationSyntax
-                .Ancestors()
-                .OfType<MethodDeclarationSyntax>()
-                .SelectMany(m => m.ParameterList.Parameters)
-                .Select(p => p.Type)
-                .Select(t => context.SemanticModel.GetSymbolInfo(t).Symbol)
-                .Where(s => s != null)
-                .Any(KnownSymbols.IsConsoleInterface!);
-
-            if (!isConsoleInterfaceAvailable)
-                return;
-
-            context.ReportDiagnostic(Diagnostic.Create(DiagnosticDescriptors.CliFx0100, invocationSyntax.GetLocation()));
-        }
-
-        public override void Initialize(AnalysisContext context)
-        {
-            context.EnableConcurrentExecution();
-            context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
-
-            context.RegisterSyntaxNodeAction(CheckSystemConsoleUsage, SyntaxKind.InvocationExpression);
-        }
-    }
-}
--- a/CliFx.Analyzers/DiagnosticDescriptors.cs
+++ b/CliFx.Analyzers/DiagnosticDescriptors.cs
@@ -1,79 +0,0 @@
-using Microsoft.CodeAnalysis;
-
-namespace CliFx.Analyzers
-{
-    public static class DiagnosticDescriptors
-    {
-        public static readonly DiagnosticDescriptor CliFx0001 =
-            new DiagnosticDescriptor(nameof(CliFx0001),
-                "Type must implement the 'CliFx.ICommand' interface in order to be a valid command",
-                "Type must implement the 'CliFx.ICommand' interface in order to be a valid command",
-                "Usage", DiagnosticSeverity.Error, true);
-
-        public static readonly DiagnosticDescriptor CliFx0002 =
-            new DiagnosticDescriptor(nameof(CliFx0002),
-                "Type must be annotated with the 'CliFx.Attributes.CommandAttribute' in order to be a valid command",
-                "Type must be annotated with the 'CliFx.Attributes.CommandAttribute' in order to be a valid command",
-                "Usage", DiagnosticSeverity.Error, true);
-
-        public static readonly DiagnosticDescriptor CliFx0021 =
-            new DiagnosticDescriptor(nameof(CliFx0021),
-                "Parameter order must be unique within its command",
-                "Parameter order must be unique within its command",
-                "Usage", DiagnosticSeverity.Error, true);
-
-        public static readonly DiagnosticDescriptor CliFx0022 =
-            new DiagnosticDescriptor(nameof(CliFx0022),
-                "Parameter order must have unique name within its command",
-                "Parameter order must have unique name within its command",
-                "Usage", DiagnosticSeverity.Error, true);
-
-        public static readonly DiagnosticDescriptor CliFx0023 =
-            new DiagnosticDescriptor(nameof(CliFx0023),
-                "Only one non-scalar parameter per command is allowed",
-                "Only one non-scalar parameter per command is allowed",
-                "Usage", DiagnosticSeverity.Error, true);
-
-        public static readonly DiagnosticDescriptor CliFx0024 =
-            new DiagnosticDescriptor(nameof(CliFx0024),
-                "Non-scalar parameter must be last in order",
-                "Non-scalar parameter must be last in order",
-                "Usage", DiagnosticSeverity.Error, true);
-
-        public static readonly DiagnosticDescriptor CliFx0041 =
-            new DiagnosticDescriptor(nameof(CliFx0041),
-                "Option must have a name or short name specified",
-                "Option must have a name or short name specified",
-                "Usage", DiagnosticSeverity.Error, true);
-
-        public static readonly DiagnosticDescriptor CliFx0042 =
-            new DiagnosticDescriptor(nameof(CliFx0042),
-                "Option name must be at least 2 characters long",
-                "Option name must be at least 2 characters long",
-                "Usage", DiagnosticSeverity.Error, true);
-
-        public static readonly DiagnosticDescriptor CliFx0043 =
-            new DiagnosticDescriptor(nameof(CliFx0043),
-                "Option name must be unique within its command",
-                "Option name must be unique within its command",
-                "Usage", DiagnosticSeverity.Error, true);
-
-        public static readonly DiagnosticDescriptor CliFx0044 =
-            new DiagnosticDescriptor(nameof(CliFx0044),
-                "Option short name must be unique within its command",
-                "Option short name must be unique within its command",
-                "Usage", DiagnosticSeverity.Error, true);
-
-        public static readonly DiagnosticDescriptor CliFx0045 =
-            new DiagnosticDescriptor(nameof(CliFx0045),
-                "Option environment variable name must be unique within its command",
-                "Option environment variable name must be unique within its command",
-                "Usage", DiagnosticSeverity.Error, true);
-
-        public static readonly DiagnosticDescriptor CliFx0100 =
-            new DiagnosticDescriptor(nameof(CliFx0100),
-                "Use the provided IConsole abstraction instead of System.Console to ensure that the command can be tested in isolation",
-                "Use the provided IConsole abstraction instead of System.Console to ensure that the command can be tested in isolation",
-                "Usage", DiagnosticSeverity.Warning, true);
-    }
-}
--- a/CliFx.Analyzers/Internal/RoslynExtensions.cs
+++ b/CliFx.Analyzers/Internal/RoslynExtensions.cs
@@ -1,11 +0,0 @@
-using System;
-using Microsoft.CodeAnalysis;
-
-namespace CliFx.Analyzers.Internal
-{
-    internal static class RoslynExtensions
-    {
-        public static bool DisplayNameMatches(this ISymbol symbol, string name) =>
-            string.Equals(symbol.ToDisplayString(), name, StringComparison.Ordinal);
-    }
-}
--- a/CliFx.Analyzers/KnownSymbols.cs
+++ b/CliFx.Analyzers/KnownSymbols.cs
@@ -1,37 +0,0 @@
-using CliFx.Analyzers.Internal;
-using Microsoft.CodeAnalysis;
-
-namespace CliFx.Analyzers
-{
-    public static class KnownSymbols
-    {
-        public static bool IsSystemString(ISymbol symbol) =>
-            symbol.DisplayNameMatches("string") ||
-            symbol.DisplayNameMatches("System.String");
-
-        public static bool IsSystemChar(ISymbol symbol) =>
-            symbol.DisplayNameMatches("char") ||
-            symbol.DisplayNameMatches("System.Char");
-
-        public static bool IsSystemCollectionsGenericIEnumerable(ISymbol symbol) =>
-            symbol.DisplayNameMatches("System.Collections.Generic.IEnumerable<T>");
-
-        public static bool IsSystemConsole(ISymbol symbol) =>
-            symbol.DisplayNameMatches("System.Console");
-
-        public static bool IsConsoleInterface(ISymbol symbol) =>
-            symbol.DisplayNameMatches("CliFx.IConsole");
-
-        public static bool IsCommandInterface(ISymbol symbol) =>
-            symbol.DisplayNameMatches("CliFx.ICommand");
-
-        public static bool IsCommandAttribute(ISymbol symbol) =>
-            symbol.DisplayNameMatches("CliFx.Attributes.CommandAttribute");
-
-        public static bool IsCommandParameterAttribute(ISymbol symbol) =>
-            symbol.DisplayNameMatches("CliFx.Attributes.CommandParameterAttribute");
-
-        public static bool IsCommandOptionAttribute(ISymbol symbol) =>
-            symbol.DisplayNameMatches("CliFx.Attributes.CommandOptionAttribute");
-    }
-}
--- a/CliFx.Analyzers/ObjectModel/CommandOptionSymbol.cs
+++ b/CliFx.Analyzers/ObjectModel/CommandOptionSymbol.cs
@@ -0,0 +1,79 @@
+using System.Collections.Generic;
+using System.Linq;
+using CliFx.Analyzers.Utils.Extensions;
+using Microsoft.CodeAnalysis;
+
+namespace CliFx.Analyzers.ObjectModel;
+
+internal partial class CommandOptionSymbol : ICommandMemberSymbol
+{
+    public IPropertySymbol Property { get; }
+
+    public string? Name { get; }
+
+    public char? ShortName { get; }
+
+    public ITypeSymbol? ConverterType { get; }
+
+    public IReadOnlyList<ITypeSymbol> ValidatorTypes { get; }
+
+    public CommandOptionSymbol(
+        IPropertySymbol property,
+        string? name,
+        char? shortName,
+        ITypeSymbol? converterType,
+        IReadOnlyList<ITypeSymbol> validatorTypes)
+    {
+        Property = property;
+        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) == true);
+
+    public static CommandOptionSymbol? TryResolve(IPropertySymbol property)
+    {
+        var attribute = TryGetOptionAttribute(property);
+        if (attribute is null)
+            return null;
+
+        var name = attribute
+            .ConstructorArguments
+            .Where(a => a.Type?.SpecialType == SpecialType.System_String)
+            .Select(a => a.Value)
+            .FirstOrDefault() as string;
+
+        var shortName = attribute
+            .ConstructorArguments
+            .Where(a => a.Type?.SpecialType == SpecialType.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(property, name, shortName, converter, validators);
+    }
+
+    public static bool IsOptionProperty(IPropertySymbol property) =>
+        TryGetOptionAttribute(property) is not null;
+}
--- a/CliFx.Analyzers/ObjectModel/CommandParameterSymbol.cs
+++ b/CliFx.Analyzers/ObjectModel/CommandParameterSymbol.cs
@@ -0,0 +1,88 @@
+using System.Collections.Generic;
+using System.Linq;
+using CliFx.Analyzers.Utils.Extensions;
+using Microsoft.CodeAnalysis;
+
+namespace CliFx.Analyzers.ObjectModel;
+
+internal partial class CommandParameterSymbol : ICommandMemberSymbol
+{
+    public IPropertySymbol Property { get; }
+
+    public int Order { get; }
+
+    public string? Name { get; }
+
+    public bool? IsRequired { get; }
+
+    public ITypeSymbol? ConverterType { get; }
+
+    public IReadOnlyList<ITypeSymbol> ValidatorTypes { get; }
+
+    public CommandParameterSymbol(
+        IPropertySymbol property,
+        int order,
+        string? name,
+        bool? isRequired,
+        ITypeSymbol? converterType,
+        IReadOnlyList<ITypeSymbol> validatorTypes)
+    {
+        Property = property;
+        Order = order;
+        Name = name;
+        IsRequired = isRequired;
+        ConverterType = converterType;
+        ValidatorTypes = validatorTypes;
+    }
+}
+
+internal partial class CommandParameterSymbol
+{
+    private static AttributeData? TryGetParameterAttribute(IPropertySymbol property) => property
+        .GetAttributes()
+        .FirstOrDefault(a => a.AttributeClass?.DisplayNameMatches(SymbolNames.CliFxCommandParameterAttribute) == true);
+
+    public static CommandParameterSymbol? TryResolve(IPropertySymbol property)
+    {
+        var attribute = TryGetParameterAttribute(property);
+        if (attribute is null)
+            return null;
+
+        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 isRequired = attribute
+            .NamedArguments
+            .Where(a => a.Key == "IsRequired")
+            .Select(a => a.Value.Value)
+            .FirstOrDefault() as bool?;
+
+        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(property, order, name, isRequired, converter, validators);
+    }
+
+    public static bool IsParameterProperty(IPropertySymbol property) =>
+        TryGetParameterAttribute(property) is not null;
+}
--- a/CliFx.Analyzers/ObjectModel/ICommandMemberSymbol.cs
+++ b/CliFx.Analyzers/ObjectModel/ICommandMemberSymbol.cs
@@ -0,0 +1,21 @@
+using System.Collections.Generic;
+using CliFx.Analyzers.Utils.Extensions;
+using Microsoft.CodeAnalysis;
+
+namespace CliFx.Analyzers.ObjectModel;
+
+internal interface ICommandMemberSymbol
+{
+    IPropertySymbol Property { get; }
+
+    ITypeSymbol? ConverterType { get; }
+
+    IReadOnlyList<ITypeSymbol> ValidatorTypes { get; }
+}
+
+internal static class CommandMemberSymbolExtensions
+{
+    public static bool IsScalar(this ICommandMemberSymbol member) =>
+        member.Property.Type.SpecialType == SpecialType.System_String ||
+        member.Property.Type.TryGetEnumerableUnderlyingType() is null;
+}
--- a/CliFx.Analyzers/ObjectModel/SymbolNames.cs
+++ b/CliFx.Analyzers/ObjectModel/SymbolNames.cs
@@ -0,0 +1,12 @@
+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 CliFxBindingConverterClass = "CliFx.Extensibility.BindingConverter<T>";
+    public const string CliFxBindingValidatorClass = "CliFx.Extensibility.BindingValidator<T>";
+}
--- a/CliFx.Analyzers/OptionMustBeInsideCommandAnalyzer.cs
+++ b/CliFx.Analyzers/OptionMustBeInsideCommandAnalyzer.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 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 is null)
+            return;
+
+        if (property.ContainingType.IsAbstract)
+            return;
+
+        if (!CommandOptionSymbol.IsOptionProperty(property))
+            return;
+
+        var isInsideCommand = property
+            .ContainingType
+            .AllInterfaces
+            .Any(i => i.DisplayNameMatches(SymbolNames.CliFxCommandInterface));
+
+        if (!isInsideCommand)
+        {
+            context.ReportDiagnostic(
+                CreateDiagnostic(propertyDeclaration.Identifier.GetLocation())
+            );
+        }
+    }
+
+    public override void Initialize(AnalysisContext context)
+    {
+        base.Initialize(context);
+        context.HandlePropertyDeclaration(Analyze);
+    }
+}
--- a/CliFx.Analyzers/OptionMustHaveNameOrShortNameAnalyzer.cs
+++ b/CliFx.Analyzers/OptionMustHaveNameOrShortNameAnalyzer.cs
@@ -0,0 +1,41 @@
+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.Identifier.GetLocation())
+            );
+        }
+    }
+
+    public override void Initialize(AnalysisContext context)
+    {
+        base.Initialize(context);
+        context.HandlePropertyDeclaration(Analyze);
+    }
+}
--- a/CliFx.Analyzers/OptionMustHaveUniqueNameAnalyzer.cs
+++ b/CliFx.Analyzers/OptionMustHaveUniqueNameAnalyzer.cs
@@ -0,0 +1,72 @@
+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). " +
+            "Specified name: `{0}`. " +
+            "Property bound to another option with the same name: `{1}`.")
+    {
+    }
+
+    private void Analyze(
+        SyntaxNodeAnalysisContext context,
+        PropertyDeclarationSyntax propertyDeclaration,
+        IPropertySymbol property)
+    {
+        if (property.ContainingType is null)
+            return;
+
+        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.Identifier.GetLocation(),
+                        option.Name,
+                        otherProperty.Name
+                    )
+                );
+            }
+        }
+    }
+
+    public override void Initialize(AnalysisContext context)
+    {
+        base.Initialize(context);
+        context.HandlePropertyDeclaration(Analyze);
+    }
+}
--- a/CliFx.Analyzers/OptionMustHaveUniqueShortNameAnalyzer.cs
+++ b/CliFx.Analyzers/OptionMustHaveUniqueShortNameAnalyzer.cs
@@ -0,0 +1,71 @@
+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). " +
+            "Specified short name: `{0}` " +
+            "Property bound to another option with the same short name: `{1}`.")
+    {
+    }
+
+    private void Analyze(
+        SyntaxNodeAnalysisContext context,
+        PropertyDeclarationSyntax propertyDeclaration,
+        IPropertySymbol property)
+    {
+        if (property.ContainingType is null)
+            return;
+
+        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.Identifier.GetLocation(),
+                        option.ShortName,
+                        otherProperty.Name
+                    )
+                );
+            }
+        }
+    }
+
+    public override void Initialize(AnalysisContext context)
+    {
+        base.Initialize(context);
+        context.HandlePropertyDeclaration(Analyze);
+    }
+}
--- a/CliFx.Analyzers/OptionMustHaveValidConverterAnalyzer.cs
+++ b/CliFx.Analyzers/OptionMustHaveValidConverterAnalyzer.cs
@@ -0,0 +1,62 @@
+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 a compatible `{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;
+
+        var converterValueType = option
+            .ConverterType
+            .GetBaseTypes()
+            .FirstOrDefault(t => t.ConstructedFrom.DisplayNameMatches(SymbolNames.CliFxBindingConverterClass))?
+            .TypeArguments
+            .FirstOrDefault();
+
+        // Value returned by the converter must be assignable to the property type
+        var isCompatible =
+            converterValueType is not null && (option.IsScalar()
+                // Scalar
+                ? context.Compilation.IsAssignable(converterValueType, property.Type)
+                // Non-scalar (assume we can handle all IEnumerable types for simplicity)
+                : property.Type.TryGetEnumerableUnderlyingType() is { } enumerableUnderlyingType &&
+                  context.Compilation.IsAssignable(converterValueType, enumerableUnderlyingType)
+            );
+
+        if (!isCompatible)
+        {
+            context.ReportDiagnostic(
+                CreateDiagnostic(propertyDeclaration.Identifier.GetLocation())
+            );
+        }
+    }
+
+    public override void Initialize(AnalysisContext context)
+    {
+        base.Initialize(context);
+        context.HandlePropertyDeclaration(Analyze);
+    }
+}
--- a/CliFx.Analyzers/OptionMustHaveValidNameAnalyzer.cs
+++ b/CliFx.Analyzers/OptionMustHaveValidNameAnalyzer.cs
@@ -0,0 +1,48 @@
+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. " +
+            "Specified name: `{0}`.")
+    {
+    }
+
+    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.Identifier.GetLocation(),
+                    option.Name
+                )
+            );
+        }
+    }
+
+    public override void Initialize(AnalysisContext context)
+    {
+        base.Initialize(context);
+        context.HandlePropertyDeclaration(Analyze);
+    }
+}
--- a/CliFx.Analyzers/OptionMustHaveValidShortNameAnalyzer.cs
+++ b/CliFx.Analyzers/OptionMustHaveValidShortNameAnalyzer.cs
@@ -0,0 +1,48 @@
+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. " +
+            "Specified short name: `{0}`.")
+    {
+    }
+
+    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.Identifier.GetLocation(),
+                    option.ShortName
+                )
+            );
+        }
+    }
+
+    public override void Initialize(AnalysisContext context)
+    {
+        base.Initialize(context);
+        context.HandlePropertyDeclaration(Analyze);
+    }
+}
--- a/CliFx.Analyzers/OptionMustHaveValidValidatorsAnalyzer.cs
+++ b/CliFx.Analyzers/OptionMustHaveValidValidatorsAnalyzer.cs
@@ -0,0 +1,59 @@
+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}`",
+            $"Each validator specified for this option must derive from a compatible `{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)
+        {
+            var validatorValueType = validatorType
+                .GetBaseTypes()
+                .FirstOrDefault(t => t.ConstructedFrom.DisplayNameMatches(SymbolNames.CliFxBindingValidatorClass))?
+                .TypeArguments
+                .FirstOrDefault();
+
+            // Value passed to the validator must be assignable from the property type
+            var isCompatible =
+                validatorValueType is not null &&
+                context.Compilation.IsAssignable(property.Type, validatorValueType);
+
+            if (!isCompatible)
+            {
+                context.ReportDiagnostic(
+                    CreateDiagnostic(propertyDeclaration.Identifier.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);
+    }
+}
--- a/CliFx.Analyzers/ParameterMustBeInsideCommandAnalyzer.cs
+++ b/CliFx.Analyzers/ParameterMustBeInsideCommandAnalyzer.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 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 is null)
+            return;
+
+        if (property.ContainingType.IsAbstract)
+            return;
+
+        if (!CommandParameterSymbol.IsParameterProperty(property))
+            return;
+
+        var isInsideCommand = property
+            .ContainingType
+            .AllInterfaces
+            .Any(i => i.DisplayNameMatches(SymbolNames.CliFxCommandInterface));
+
+        if (!isInsideCommand)
+        {
+            context.ReportDiagnostic(
+                CreateDiagnostic(propertyDeclaration.Identifier.GetLocation())
+            );
+        }
+    }
+
+    public override void Initialize(AnalysisContext context)
+    {
+        base.Initialize(context);
+        context.HandlePropertyDeclaration(Analyze);
+    }
+}
--- a/CliFx.Analyzers/ParameterMustBeLastIfNonRequiredAnalyzer.cs
+++ b/CliFx.Analyzers/ParameterMustBeLastIfNonRequiredAnalyzer.cs
@@ -0,0 +1,66 @@
+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 ParameterMustBeLastIfNonRequiredAnalyzer : AnalyzerBase
+{
+    public ParameterMustBeLastIfNonRequiredAnalyzer()
+        : base(
+            "Parameters marked as non-required must be the last in order",
+            "This parameter is non-required so it must be the last in order (its order must be highest within the command). " +
+            "Property bound to another non-required parameter: `{0}`.")
+    {
+    }
+
+    private void Analyze(
+        SyntaxNodeAnalysisContext context,
+        PropertyDeclarationSyntax propertyDeclaration,
+        IPropertySymbol property)
+    {
+        if (property.ContainingType is null)
+            return;
+
+        var parameter = CommandParameterSymbol.TryResolve(property);
+        if (parameter is null)
+            return;
+
+        if (parameter.IsRequired != false)
+            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.Identifier.GetLocation(),
+                        otherProperty.Name
+                    )
+                );
+            }
+        }
+    }
+
+    public override void Initialize(AnalysisContext context)
+    {
+        base.Initialize(context);
+        context.HandlePropertyDeclaration(Analyze);
+    }
+}
--- a/CliFx.Analyzers/ParameterMustBeLastIfNonScalarAnalyzer.cs
+++ b/CliFx.Analyzers/ParameterMustBeLastIfNonScalarAnalyzer.cs
@@ -0,0 +1,66 @@
+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 the last in order",
+            "This parameter has a non-scalar type so it must be the last in order (its order must be highest within the command). " +
+            "Property bound to another non-scalar parameter: `{0}`.")
+    {
+    }
+
+    private void Analyze(
+        SyntaxNodeAnalysisContext context,
+        PropertyDeclarationSyntax propertyDeclaration,
+        IPropertySymbol property)
+    {
+        if (property.ContainingType is null)
+            return;
+
+        var parameter = CommandParameterSymbol.TryResolve(property);
+        if (parameter is null)
+            return;
+
+        if (parameter.IsScalar())
+            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.Identifier.GetLocation(),
+                        otherProperty.Name
+                    )
+                );
+            }
+        }
+    }
+
+    public override void Initialize(AnalysisContext context)
+    {
+        base.Initialize(context);
+        context.HandlePropertyDeclaration(Analyze);
+    }
+}
--- a/CliFx.Analyzers/ParameterMustBeSingleIfNonRequiredAnalyzer.cs
+++ b/CliFx.Analyzers/ParameterMustBeSingleIfNonRequiredAnalyzer.cs
@@ -0,0 +1,66 @@
+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 ParameterMustBeSingleIfNonRequiredAnalyzer : AnalyzerBase
+{
+    public ParameterMustBeSingleIfNonRequiredAnalyzer()
+        : base(
+            "Parameters marked as non-required are limited to one per command",
+            "This parameter is non-required so it must be the only such parameter in the command. " +
+            "Property bound to another non-required parameter: `{0}`.")
+    {
+    }
+
+    private void Analyze(
+        SyntaxNodeAnalysisContext context,
+        PropertyDeclarationSyntax propertyDeclaration,
+        IPropertySymbol property)
+    {
+        if (property.ContainingType is null)
+            return;
+
+        var parameter = CommandParameterSymbol.TryResolve(property);
+        if (parameter is null)
+            return;
+
+        if (parameter.IsRequired != false)
+            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.IsRequired == false)
+            {
+                context.ReportDiagnostic(
+                    CreateDiagnostic(
+                        propertyDeclaration.Identifier.GetLocation(),
+                        otherProperty.Name
+                    )
+                );
+            }
+        }
+    }
+
+    public override void Initialize(AnalysisContext context)
+    {
+        base.Initialize(context);
+        context.HandlePropertyDeclaration(Analyze);
+    }
+}
--- a/CliFx.Analyzers/ParameterMustBeSingleIfNonScalarAnalyzer.cs
+++ b/CliFx.Analyzers/ParameterMustBeSingleIfNonScalarAnalyzer.cs
@@ -0,0 +1,66 @@
+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. " +
+            "Property bound to another non-scalar parameter: `{0}`.")
+    {
+    }
+
+    private void Analyze(
+        SyntaxNodeAnalysisContext context,
+        PropertyDeclarationSyntax propertyDeclaration,
+        IPropertySymbol property)
+    {
+        if (property.ContainingType is null)
+            return;
+
+        var parameter = CommandParameterSymbol.TryResolve(property);
+        if (parameter is null)
+            return;
+
+        if (parameter.IsScalar())
+            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.IsScalar())
+            {
+                context.ReportDiagnostic(
+                    CreateDiagnostic(
+                        propertyDeclaration.Identifier.GetLocation(),
+                        otherProperty.Name
+                    )
+                );
+            }
+        }
+    }
+
+    public override void Initialize(AnalysisContext context)
+    {
+        base.Initialize(context);
+        context.HandlePropertyDeclaration(Analyze);
+    }
+}
--- a/CliFx.Analyzers/ParameterMustHaveUniqueNameAnalyzer.cs
+++ b/CliFx.Analyzers/ParameterMustHaveUniqueNameAnalyzer.cs
@@ -0,0 +1,72 @@
+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). " +
+            "Specified name: `{0}`. " +
+            "Property bound to another parameter with the same name: `{1}`.")
+    {
+    }
+
+    private void Analyze(
+        SyntaxNodeAnalysisContext context,
+        PropertyDeclarationSyntax propertyDeclaration,
+        IPropertySymbol property)
+    {
+        if (property.ContainingType is null)
+            return;
+
+        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.Identifier.GetLocation(),
+                        parameter.Name,
+                        otherProperty.Name
+                    )
+                );
+            }
+        }
+    }
+
+    public override void Initialize(AnalysisContext context)
+    {
+        base.Initialize(context);
+        context.HandlePropertyDeclaration(Analyze);
+    }
+}
--- a/CliFx.Analyzers/ParameterMustHaveUniqueOrderAnalyzer.cs
+++ b/CliFx.Analyzers/ParameterMustHaveUniqueOrderAnalyzer.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 ParameterMustHaveUniqueOrderAnalyzer : AnalyzerBase
+{
+    public ParameterMustHaveUniqueOrderAnalyzer()
+        : base(
+            "Parameters must have unique order",
+            "This parameter's order must be unique within the command. " +
+            "Specified order: {0}. " +
+            "Property bound to another parameter with the same order: `{1}`.")
+    {
+    }
+
+    private void Analyze(
+        SyntaxNodeAnalysisContext context,
+        PropertyDeclarationSyntax propertyDeclaration,
+        IPropertySymbol property)
+    {
+        if (property.ContainingType is null)
+            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 (parameter.Order == otherParameter.Order)
+            {
+                context.ReportDiagnostic(
+                    CreateDiagnostic(
+                        propertyDeclaration.Identifier.GetLocation(),
+                        parameter.Order,
+                        otherProperty.Name
+                    )
+                );
+            }
+        }
+    }
+
+    public override void Initialize(AnalysisContext context)
+    {
+        base.Initialize(context);
+        context.HandlePropertyDeclaration(Analyze);
+    }
+}
--- a/CliFx.Analyzers/ParameterMustHaveValidConverterAnalyzer.cs
+++ b/CliFx.Analyzers/ParameterMustHaveValidConverterAnalyzer.cs
@@ -0,0 +1,62 @@
+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 a compatible `{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;
+
+        var converterValueType = parameter
+            .ConverterType
+            .GetBaseTypes()
+            .FirstOrDefault(t => t.ConstructedFrom.DisplayNameMatches(SymbolNames.CliFxBindingConverterClass))?
+            .TypeArguments
+            .FirstOrDefault();
+
+        // Value returned by the converter must be assignable to the property type
+        var isCompatible =
+            converterValueType is not null && (parameter.IsScalar()
+                // Scalar
+                ? context.Compilation.IsAssignable(converterValueType, property.Type)
+                // Non-scalar (assume we can handle all IEnumerable types for simplicity)
+                : property.Type.TryGetEnumerableUnderlyingType() is { } enumerableUnderlyingType &&
+                  context.Compilation.IsAssignable(converterValueType, enumerableUnderlyingType)
+            );
+
+        if (!isCompatible)
+        {
+            context.ReportDiagnostic(
+                CreateDiagnostic(propertyDeclaration.Identifier.GetLocation())
+            );
+        }
+    }
+
+    public override void Initialize(AnalysisContext context)
+    {
+        base.Initialize(context);
+        context.HandlePropertyDeclaration(Analyze);
+    }
+}
--- a/CliFx.Analyzers/ParameterMustHaveValidValidatorsAnalyzer.cs
+++ b/CliFx.Analyzers/ParameterMustHaveValidValidatorsAnalyzer.cs
@@ -0,0 +1,59 @@
+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}`",
+            $"Each validator specified for this parameter must derive from a compatible `{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)
+        {
+            var validatorValueType = validatorType
+                .GetBaseTypes()
+                .FirstOrDefault(t => t.ConstructedFrom.DisplayNameMatches(SymbolNames.CliFxBindingValidatorClass))?
+                .TypeArguments
+                .FirstOrDefault();
+
+            // Value passed to the validator must be assignable from the property type
+            var isCompatible =
+                validatorValueType is not null &&
+                context.Compilation.IsAssignable(property.Type, validatorValueType);
+
+            if (!isCompatible)
+            {
+                context.ReportDiagnostic(
+                    CreateDiagnostic(propertyDeclaration.Identifier.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);
+    }
+}
--- a/CliFx.Analyzers/SystemConsoleShouldBeAvoidedAnalyzer.cs
+++ b/CliFx.Analyzers/SystemConsoleShouldBeAvoidedAnalyzer.cs
@@ -0,0 +1,79 @@
+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 member = context.SemanticModel.GetSymbolInfo(memberAccess).Symbol;
+
+            if (member?.ContainingType?.DisplayNameMatches("System.Console") == true)
+            {
+                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);
+    }
+}
--- a/CliFx.Analyzers/Utils/Extensions/RoslynExtensions.cs
+++ b/CliFx.Analyzers/Utils/Extensions/RoslynExtensions.cs
@@ -0,0 +1,73 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+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(
+            // Fully qualified name, without `global::`
+            symbol.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat),
+            name,
+            StringComparison.Ordinal
+        );
+
+    public static IEnumerable<INamedTypeSymbol> GetBaseTypes(this ITypeSymbol type)
+    {
+        var current = type.BaseType;
+
+        while (current is not null)
+        {
+            yield return current;
+            current = current.BaseType;
+        }
+    }
+
+    public static ITypeSymbol? TryGetEnumerableUnderlyingType(this ITypeSymbol type) => type
+        .AllInterfaces
+        .FirstOrDefault(i => i.ConstructedFrom.SpecialType == SpecialType.System_Collections_Generic_IEnumerable_T)?
+        .TypeArguments[0];
+
+    public static bool IsAssignable(this Compilation compilation, ITypeSymbol source, ITypeSymbol destination) =>
+        compilation.ClassifyConversion(source, destination).Exists;
+
+    public static void HandleClassDeclaration(
+        this AnalysisContext analysisContext,
+        Action<SyntaxNodeAnalysisContext, ClassDeclarationSyntax, ITypeSymbol> analyze)
+    {
+        analysisContext.RegisterSyntaxNodeAction(ctx =>
+        {
+            if (ctx.Node is not ClassDeclarationSyntax classDeclaration)
+                return;
+
+            var type = ctx.SemanticModel.GetDeclaredSymbol(classDeclaration);
+            if (type is null)
+                return;
+
+            analyze(ctx, classDeclaration, type);
+        }, SyntaxKind.ClassDeclaration);
+    }
+
+    public static void HandlePropertyDeclaration(
+        this AnalysisContext analysisContext,
+        Action<SyntaxNodeAnalysisContext, PropertyDeclarationSyntax, IPropertySymbol> analyze)
+    {
+        analysisContext.RegisterSyntaxNodeAction(ctx =>
+        {
+            if (ctx.Node is not PropertyDeclarationSyntax propertyDeclaration)
+                return;
+
+            var property = ctx.SemanticModel.GetDeclaredSymbol(propertyDeclaration);
+            if (property is null)
+                return;
+
+            analyze(ctx, propertyDeclaration, property);
+        }, SyntaxKind.PropertyDeclaration);
+    }
+}
--- a/CliFx.Analyzers/Utils/Extensions/StringExtensions.cs
+++ b/CliFx.Analyzers/Utils/Extensions/StringExtensions.cs
@@ -0,0 +1,17 @@
+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;
+    }
+}
--- a/CliFx.Benchmarks/Benchmarks.CliFx.cs
+++ b/CliFx.Benchmarks/Benchmarks.CliFx.cs
@@ -0,0 +1,32 @@
+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>());
+}
--- a/CliFx.Benchmarks/Commands/CliprCommand.cs
+++ b/CliFx.Benchmarks/Commands/CliprCommand.cs
@@ -1,6 +1,9 @@
-using clipr;
+using BenchmarkDotNet.Attributes;
+using clipr;

-namespace CliFx.Benchmarks.Commands
+namespace CliFx.Benchmarks;
+
+public partial class Benchmarks
 {
    public class CliprCommand
    {
@@ -17,4 +20,7 @@ namespace CliFx.Benchmarks.Commands
        {
        }
    }
+
+    [Benchmark(Description = "Clipr")]
+    public void ExecuteWithClipr() => CliParser.Parse<CliprCommand>(Arguments).Execute();
 }
--- a/CliFx.Benchmarks/Commands/CoconaCommand.cs
+++ b/CliFx.Benchmarks/Commands/CoconaCommand.cs
@@ -1,6 +1,9 @@
-using Cocona;
+using BenchmarkDotNet.Attributes;
+using Cocona;

-namespace CliFx.Benchmarks.Commands
+namespace CliFx.Benchmarks;
+
+public partial class Benchmarks
 {
    public class CoconaCommand
    {
@@ -14,4 +17,7 @@ namespace CliFx.Benchmarks.Commands
        {
        }
    }
+
+    [Benchmark(Description = "Cocona")]
+    public void ExecuteWithCocona() => CoconaApp.Run<CoconaCommand>(Arguments);
 }
--- a/CliFx.Benchmarks/Benchmarks.CommandLineParser.cs
+++ b/CliFx.Benchmarks/Benchmarks.CommandLineParser.cs
@@ -0,0 +1,29 @@
+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());
+}
--- a/CliFx.Benchmarks/Benchmarks.McMaster.cs
+++ b/CliFx.Benchmarks/Benchmarks.McMaster.cs
@@ -0,0 +1,24 @@
+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);
+}
--- a/CliFx.Benchmarks/Commands/PowerArgsCommand.cs
+++ b/CliFx.Benchmarks/Commands/PowerArgsCommand.cs
@@ -1,6 +1,9 @@
-using PowerArgs;
+using BenchmarkDotNet.Attributes;
+using PowerArgs;

-namespace CliFx.Benchmarks.Commands
+namespace CliFx.Benchmarks;
+
+public partial class Benchmarks
 {
    public class PowerArgsCommand
    {
@@ -17,4 +20,7 @@ namespace CliFx.Benchmarks.Commands
        {
        }
    }
+
+    [Benchmark(Description = "PowerArgs")]
+    public void ExecuteWithPowerArgs() => Args.InvokeMain<PowerArgsCommand>(Arguments);
 }
--- a/CliFx.Benchmarks/Commands/SystemCommandLineCommand.cs
+++ b/CliFx.Benchmarks/Commands/SystemCommandLineCommand.cs
@@ -1,8 +1,11 @@
 using System.CommandLine;
 using System.CommandLine.Invocation;
 using System.Threading.Tasks;
+using BenchmarkDotNet.Attributes;

-namespace CliFx.Benchmarks.Commands
+namespace CliFx.Benchmarks;
+
+public partial class Benchmarks
 {
    public class SystemCommandLineCommand
    {
@@ -26,9 +29,15 @@ namespace CliFx.Benchmarks.Commands
                }
            };

-            command.Handler = CommandHandler.Create(typeof(SystemCommandLineCommand).GetMethod(nameof(ExecuteHandler)));
+            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);
 }
--- a/CliFx.Benchmarks/Benchmarks.cs
+++ b/CliFx.Benchmarks/Benchmarks.cs
@@ -1,52 +1,19 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Configs;
 using BenchmarkDotNet.Order;
 using BenchmarkDotNet.Running;
-using CliFx.Benchmarks.Commands;
-using CommandLine;

-namespace CliFx.Benchmarks
-{
-    [SimpleJob]
+namespace CliFx.Benchmarks;
+
 [RankColumn]
 [Orderer(SummaryOrderPolicy.FastestToSlowest)]
-    public class Benchmarks
+public partial class Benchmarks
 {
    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, new Dictionary<string, string>());
-
-        [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);
-
-        public static void Main() =>
-            BenchmarkRunner.Run<Benchmarks>(DefaultConfig.Instance.With(ConfigOptions.DisableOptimizationsValidator));
-    }
+    public static void Main() => BenchmarkRunner.Run<Benchmarks>(
+        DefaultConfig
+            .Instance
+            .WithOptions(ConfigOptions.DisableOptimizationsValidator)
+    );
 }
--- a/CliFx.Benchmarks/CliFx.Benchmarks.csproj
+++ b/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>net6.0</TargetFramework>
  </PropertyGroup>

  <ItemGroup>
-    <PackageReference Include="BenchmarkDotNet" Version="0.12.0" />
+    <PackageReference Include="BenchmarkDotNet" Version="0.13.1" />
    <PackageReference Include="clipr" Version="1.6.1" />
-    <PackageReference Include="Cocona" Version="1.3.0" />
-    <PackageReference Include="CommandLineParser" Version="2.7.82" />
-    <PackageReference Include="McMaster.Extensions.CommandLineUtils" Version="2.6.0" />
+    <PackageReference Include="Cocona" Version="2.0.3" />
+    <PackageReference Include="CommandLineParser" Version="2.8.0" />
+    <PackageReference Include="McMaster.Extensions.CommandLineUtils" Version="4.0.1" />
    <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>
--- a/CliFx.Benchmarks/Commands/CliFxCommand.cs
+++ b/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;
-    }
-}
--- a/CliFx.Benchmarks/Commands/CommandLineParserCommand.cs
+++ b/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()
-        {
-        }
-    }
-}
--- a/CliFx.Benchmarks/Commands/McMasterCommand.cs
+++ b/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;
-    }
-}
--- a/CliFx.Benchmarks/Readme.md
+++ b/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 |
--- a/CliFx.Demo/CliFx.Demo.csproj
+++ b/CliFx.Demo/CliFx.Demo.csproj
@@ -1,19 +1,18 @@
 <Project Sdk="Microsoft.NET.Sdk">
-  <Import Project="../CliFx.props" />

  <PropertyGroup>
    <OutputType>Exe</OutputType>
-    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <TargetFramework>net6.0</TargetFramework>
  </PropertyGroup>

  <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="3.1.2" />
-    <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="6.0.0" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
  </ItemGroup>

  <ItemGroup>
    <ProjectReference Include="..\CliFx\CliFx.csproj" />
-    <ProjectReference Include="..\CliFx.Analyzers\CliFx.Analyzers.csproj" ReferenceOutputAssembly="false" OutputItemType="Analyzer" />
+    <ProjectReference Include="..\CliFx.Analyzers\CliFx.Analyzers.csproj" ReferenceOutputAssembly="false" OutputItemType="analyzer" />
  </ItemGroup>

 </Project>
--- a/CliFx.Demo/Commands/BookAddCommand.cs
+++ b/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;

-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,23 @@ 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)
+    );
 }
--- a/CliFx.Demo/Commands/BookCommand.cs
+++ b/CliFx.Demo/Commands/BookCommand.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.Exceptions;
+using CliFx.Infrastructure;

-namespace CliFx.Demo.Commands
-{
-    [Command("book", Description = "View, list, add or remove books.")]
+namespace CliFx.Demo.Commands;
+
+[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;
    }
 }
-}
--- a/CliFx.Demo/Commands/BookListCommand.cs
+++ b/CliFx.Demo/Commands/BookListCommand.cs
@@ -1,37 +1,36 @@
 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;

-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;
    }
 }
-}
--- a/CliFx.Demo/Commands/BookRemoveCommand.cs
+++ b/CliFx.Demo/Commands/BookRemoveCommand.cs
@@ -1,35 +1,35 @@
 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;

-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.");

        return default;
    }
 }
-}
--- a/CliFx.Demo/Domain/Book.cs
+++ b/CliFx.Demo/Domain/Book.cs
@@ -0,0 +1,22 @@
+using System;
+
+namespace CliFx.Demo.Domain;
+
+public class Book
+{
+    public string Title { get; }
+
+    public string Author { get; }
+
+    public DateTimeOffset Published { get; }
+
+    public Isbn Isbn { get; }
+
+    public Book(string title, string author, DateTimeOffset published, Isbn isbn)
+    {
+        Title = title;
+        Author = author;
+        Published = published;
+        Isbn = isbn;
+    }
+}
--- a/CliFx.Demo/Domain/Isbn.cs
+++ b/CliFx.Demo/Domain/Isbn.cs
@@ -0,0 +1,44 @@
+using System;
+
+namespace CliFx.Demo.Domain;
+
+public partial class Isbn
+{
+    public int EanPrefix { get; }
+
+    public int RegistrationGroup { get; }
+
+    public int Registrant { get; }
+
+    public int Publication { get; }
+
+    public int CheckDigit { get; }
+
+    public Isbn(int eanPrefix, int registrationGroup, int registrant, int publication, int checkDigit)
+    {
+        EanPrefix = eanPrefix;
+        RegistrationGroup = registrationGroup;
+        Registrant = registrant;
+        Publication = publication;
+        CheckDigit = checkDigit;
+    }
+
+    public override string ToString() =>
+        $"{EanPrefix:000}-{RegistrationGroup:00}-{Registrant:00000}-{Publication:00}-{CheckDigit:0}";
+}
+
+public partial class Isbn
+{
+    public static Isbn Parse(string value, IFormatProvider formatProvider)
+    {
+        var components = value.Split('-', 5, StringSplitOptions.RemoveEmptyEntries);
+
+        return new Isbn(
+            int.Parse(components[0], formatProvider),
+            int.Parse(components[1], formatProvider),
+            int.Parse(components[2], formatProvider),
+            int.Parse(components[3], formatProvider),
+            int.Parse(components[4], formatProvider)
+        );
+    }
+}
--- a/CliFx.Demo/Domain/Library.cs
+++ b/CliFx.Demo/Domain/Library.cs
@@ -0,0 +1,35 @@
+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>());
+}
--- a/CliFx.Demo/Domain/LibraryProvider.cs
+++ b/CliFx.Demo/Domain/LibraryProvider.cs
@@ -0,0 +1,40 @@
+using System.IO;
+using System.Linq;
+using Newtonsoft.Json;
+
+namespace CliFx.Demo.Domain;
+
+public class LibraryProvider
+{
+    private static string StorageFilePath { get; } = Path.Combine(Directory.GetCurrentDirectory(), "Library.json");
+
+    private void StoreLibrary(Library library)
+    {
+        var data = JsonConvert.SerializeObject(library);
+        File.WriteAllText(StorageFilePath, data);
+    }
+
+    public Library GetLibrary()
+    {
+        if (!File.Exists(StorageFilePath))
+            return Library.Empty;
+
+        var data = File.ReadAllText(StorageFilePath);
+
+        return JsonConvert.DeserializeObject<Library>(data) ?? Library.Empty;
+    }
+
+    public Book? TryGetBook(string title) => GetLibrary().Books.FirstOrDefault(b => b.Title == title);
+
+    public void AddBook(Book book)
+    {
+        var updatedLibrary = GetLibrary().WithBook(book);
+        StoreLibrary(updatedLibrary);
+    }
+
+    public void RemoveBook(Book book)
+    {
+        var updatedLibrary = GetLibrary().WithoutBook(book);
+        StoreLibrary(updatedLibrary);
+    }
+}
--- a/CliFx.Demo/Internal/Extensions.cs
+++ b/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));
-        }
-    }
-}
--- a/CliFx.Demo/Models/Book.cs
+++ b/CliFx.Demo/Models/Book.cs
@@ -1,23 +0,0 @@
-using System;
-
-namespace CliFx.Demo.Models
-{
-    public class Book
-    {
-        public string Title { get; }
-
-        public string Author { get; }
-
-        public DateTimeOffset Published { get; }
-
-        public Isbn Isbn { get; }
-
-        public Book(string title, string author, DateTimeOffset published, Isbn isbn)
-        {
-            Title = title;
-            Author = author;
-            Published = published;
-            Isbn = isbn;
-        }
-    }
-}
--- a/CliFx.Demo/Models/Extensions.cs
+++ b/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);
-        }
-    }
-}
--- a/CliFx.Demo/Models/Isbn.cs
+++ b/CliFx.Demo/Models/Isbn.cs
@@ -1,45 +0,0 @@
-using System;
-
-namespace CliFx.Demo.Models
-{
-    public partial class Isbn
-    {
-        public int EanPrefix { get; }
-
-        public int RegistrationGroup { get; }
-
-        public int Registrant { get; }
-
-        public int Publication { get; }
-
-        public int CheckDigit { get; }
-
-        public Isbn(int eanPrefix, int registrationGroup, int registrant, int publication, int checkDigit)
-        {
-            EanPrefix = eanPrefix;
-            RegistrationGroup = registrationGroup;
-            Registrant = registrant;
-            Publication = publication;
-            CheckDigit = checkDigit;
-        }
-
-        public override string ToString() =>
-            $"{EanPrefix:000}-{RegistrationGroup:00}-{Registrant:00000}-{Publication:00}-{CheckDigit:0}";
-    }
-
-    public partial class Isbn
-    {
-        public static Isbn Parse(string value, IFormatProvider formatProvider)
-        {
-            var components = value.Split('-', 5, StringSplitOptions.RemoveEmptyEntries);
-
-            return new Isbn(
-                int.Parse(components[0], formatProvider),
-                int.Parse(components[1], formatProvider),
-                int.Parse(components[2], formatProvider),
-                int.Parse(components[3], formatProvider),
-                int.Parse(components[4], formatProvider)
-            );
-        }
-    }
-}
--- a/CliFx.Demo/Models/Library.cs
+++ b/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>());
-    }
-}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Oleksii Holub	5ec732fe9a	Update version	2022-05-09 23:27:55 +03:00
Oleksii Holub	6d87411dbf	Update NuGet packages	2022-05-09 23:27:33 +03:00
Oleksii Holub	ed3054c855	More consistent code style	2022-04-25 19:07:18 +03:00
Oleksii Holub	5d00de4dfe	Update CliWrap	2022-04-25 19:05:23 +03:00
Oleksii Holub	016ec8b186	Make default executable name resolution smarter	2022-04-24 23:45:10 +03:00
Oleksii Holub	9141092919	Merge branch 'master' of github.com:Tyrrrz/CliFx	2022-04-24 22:59:49 +03:00
Oleksii Holub	1fe97b0140	Typo in docs	2022-04-24 22:59:38 +03:00
Oleksii Holub	6ad5989c25	Update readme	2022-04-24 19:54:37 +00:00
Oleksii Holub	7e1db916fc	Update readme	2022-04-23 21:26:54 +00:00
Oleksii Holub	1c69d5c80d	Update readme	2022-04-23 23:44:22 +03:00
Oleksii Holub	ab87225f1f	Cleanup	2022-04-22 22:33:55 +03:00
Oleksii Holub	6d33c5cdad	Update version	2022-04-22 19:15:44 +03:00
Oleksii Holub	e4c899c6c2	Reduce version of Microsoft.CodeAnalysis.CSharp further	2022-04-22 18:55:47 +03:00
Oleksii Holub	35b3ad0d63	Don't use Fody but also don't bundle Microsoft.CodeAnalysis.CSharp	2022-04-22 18:45:46 +03:00
Oleksii Holub	4e70557b47	Reorganize assets	2022-04-22 17:16:51 +03:00
Oleksii Holub	0a8d58255a	Update NuGet.config	2022-04-22 16:58:21 +03:00
Oleksii Holub	d3fbc9c643	Merge analyzer project dependencies using Fody.Costura Closes #127	2022-04-22 16:41:24 +03:00
Oleksii Holub	1cbf8776be	Don't produce color codes in tests	2022-04-21 22:57:14 +03:00
Oleksii Holub	16e33f7b8f	Update workflow	2022-04-21 22:51:11 +03:00
Oleksii Holub	5c848056c5	Add more contextual information to diagnostics	2022-04-20 20:27:53 +03:00
Oleksii Holub	864efd3179	Fix converter analyzer false positive when handling non-scalars or nullable types	2022-04-20 20:09:14 +03:00
Oleksii Holub	7f206a0c77	Update test logger	2022-04-19 01:31:40 +00:00
Oleksii Holub	22c15f8ec6	Update test logger	2022-04-18 19:53:52 +00:00
Oleksii Holub	59373eadc2	Update version	2022-04-17 00:20:26 +00:00
Oleksii Holub	ed3e4f471e	Improve analyzer diagnostics	2022-04-17 00:01:34 +00:00
Oleksii Holub	41cb8647b5	Produce analyzer errors for invalid generic arguments in converters and validators Closes #103	2022-04-16 22:54:57 +00:00
Oleksii Holub	c7015181e1	Update documentation	2022-04-16 15:34:58 +00:00
Oleksii Holub	86742755e8	Don't wrap default type activator exception if it's not related to constructor	2022-04-16 13:54:44 +00:00
Oleksii Holub	33f95d941d	Use coverlet collector	2022-04-06 21:06:05 +00:00
Oleksii Holub	1328592cb5	Update Readme.md	2022-03-22 10:41:12 -07:00
Oleksii Holub	0711b863ea	Update Readme.md	2022-03-21 10:12:22 -07:00
Oleksii Holub	a2f5cd54be	Add terms of use	2022-03-05 09:46:14 -08:00
Oleksii Holub	7836ec610f	Fuck Russia	2022-02-23 18:23:37 +02:00
Oleksii Holub	2e489927eb	Update NuGet packages	2022-02-21 22:37:10 +02:00
Oleksii Holub	02e8d19e48	Refactor polyfills	2022-02-21 22:35:23 +02:00
Oleksii Holub	eb7107fb0a	Return key in `IConsole.ReadKey(...)` Closes #124	2022-02-19 01:32:58 +02:00
Oleksii Holub	a396009b62	Use expression bodied methods in more places	2022-01-30 19:11:23 +02:00
Oleksii Holub	1d9c7e942c	Update version	2022-01-30 19:09:22 +02:00
Oleksii Holub	0f3abb9db4	Fix thread-safety of ConsoleWriter and ConsoleReader Fixes #123	2022-01-30 19:07:22 +02:00
Oleksii Holub	896482821c	Copy all analyzer dependencies to package	2022-01-21 01:16:59 +02:00
Oleksii Holub	aa3094ee54	Update version	2022-01-16 19:29:50 +02:00
Tyrrrz	712580e3d7	Update my name to match correct spelling	2022-01-15 03:24:06 +02:00
AliReZa Sabouri	c08102f85f	Show default values for optional parameters (#122 )	2022-01-11 05:22:13 -08:00
Tyrrrz	5e684c8b36	Update version	2022-01-11 00:40:30 +02:00
Tyrrrz	300ae70564	Update NuGet packages	2022-01-11 00:39:19 +02:00
Tyrrrz	76f0c77f1e	Update readme	2022-01-11 00:32:56 +02:00
Tyrrrz	0f7cea4ed1	Add some more analyzer tests	2022-01-10 23:56:54 +02:00
Tyrrrz	32ee0b2bd6	Add test for optional parameters	2022-01-10 23:48:38 +02:00
Tyrrrz	4ff1e1d3e1	Cleanup	2022-01-10 23:41:28 +02:00
AliReZa Sabouri	8e96d2701d	Add support for optional parameters (#119 )	2022-01-10 13:11:04 -08:00
Tyrrrz	8e307df231	More cleanup	2022-01-10 16:55:43 +02:00
Tyrrrz	ff38f4916a	Cleanup	2022-01-10 16:45:41 +02:00
AliReZa Sabouri	7cbbb220b4	Fix tests for default interface members (#121 )	2022-01-09 20:29:57 -08:00
AliReZa Sabouri	ae2d4299f0	Add multiple inheritance support through interfaces (#120 )	2022-01-09 08:11:42 -08:00
Tyrrrz	21bc69d116	Make projects not packable by default	2022-01-04 22:48:33 +02:00
Tyrrrz	05a70175cc	Update version	2022-01-04 22:35:59 +02:00
Tyrrrz	33ec2eb3a0	Cleanup	2022-01-04 22:31:50 +02:00
David Fallah	f6ef6cd4c0	Fix ordering of parameters within command help usage (#118 )	2022-01-04 12:12:17 -08:00
Tyrrrz	a9ef693dc1	Share more stuff	2021-12-11 00:11:20 +02:00
Tyrrrz	98bbd666dc	Update badges	2021-12-10 23:22:22 +02:00
Tyrrrz	4e7ed830f8	Move to shared workflows	2021-12-10 23:21:38 +02:00
Tyrrrz	ef87ff76fc	Use top-level statements in demo	2021-12-08 23:52:33 +02:00
Tyrrrz	2feeb21270	C#10ify	2021-12-08 23:43:35 +02:00
Tyrrrz	9990387cfa	Update readme	2021-12-05 22:20:00 +02:00
Tyrrrz	bc1bdca7c6	Update nuget packages	2021-12-05 22:05:21 +02:00
Tyrrrz	2a992d37df	Update readme	2021-12-05 21:59:53 +02:00
Tyrrrz	15c87aecbb	Update CI to .NET 6	2021-11-08 23:34:14 +02:00
Alexey Golub	10a46451ac	Update Readme.md	2021-09-30 15:21:11 -07:00
Alexey Golub	e4c6a4174b	Update readme	2021-09-04 04:20:38 -07:00
Alexey Golub	4c65f7bbee	Update readme	2021-08-30 18:34:26 -07:00
Alexey Golub	5f21de0df5	Refactor webhook in CD	2021-08-28 10:30:58 -07:00
Alexey Golub	9b01b67d98	Update CD	2021-07-28 15:13:09 -07:00
Tyrrrz	4508f5e211	Add Discord	2021-07-26 19:30:54 +03:00
Alex Rosenfeld	f0cbc46df4	Add ReadKey to IConsole (#111 ) Co-authored-by: Alexey Golub <tyrrrrrr@gmail.com>	2021-07-23 11:46:00 -07:00
Alex Rosenfeld	6c96e9e173	Add a clear console function (#110 )	2021-07-19 04:33:07 -07:00
Tyrrrz	51cca36d2a	Update version	2021-07-17 21:37:32 +03:00
Tyrrrz	84672c92f6	Unwrap `TargetInvocationException` to provide more user-friendly errors when binding fails	2021-07-17 21:32:15 +03:00
Tyrrrz	b1d01898b6	Add test for preamble omission	2021-07-10 19:43:21 +03:00
Tyrrrz	441a47a1a8	Update version	2021-07-09 22:23:46 +03:00
Tyrrrz	8abd7219a1	Better shimming in NoPreambleEncoding	2021-07-09 22:00:31 +03:00
Tyrrrz	df73a0bfe8	Update GitHib issue forms	2021-06-24 21:40:08 +03:00
Tyrrrz	55d12dc721	Add readme to package	2021-06-17 20:36:35 +03:00
Alexey Golub	a6ee44c1bb	Fix typo in readme	2021-06-13 06:19:26 -07:00
Tyrrrz	76816e22f1	Use Basic.Reference.Assemblies to simplify reference resolving for dynamic assemblies in tests Note: bumped `Microsoft.CodeAnalysis.CSharp` in test projects, but didn't touch the one in CliFx.Analyzers as it may have unintended side-effects.	2021-05-10 21:10:42 +03:00
Tyrrrz	daf25e59d6	Fix deprecation warning	2021-05-10 21:06:36 +03:00
Tyrrrz	f2b4e53615	Update version	2021-04-24 20:59:10 +03:00
Tyrrrz	2d519ab190	Remove the usage of ConsoleColor.DarkGray because it looks bad in some terminals Fixes #104	2021-04-24 20:48:06 +03:00
Tyrrrz	2d479c9cb6	Refactor	2021-04-24 20:43:35 +03:00
Tyrrrz	2bb7e13e51	Use issue forms	2021-04-22 22:11:39 +03:00
Tyrrrz	6e1dfdcdd4	Update readme	2021-04-22 21:08:16 +03:00
Tyrrrz	5ba647e5c1	Update readme	2021-04-22 21:05:35 +03:00
Tyrrrz	853492695f	Update readme	2021-04-22 21:04:36 +03:00
Robert Dailey	d5d72c7c50	Show choices for nullable enums in enumerable (#105 )	2021-04-22 15:28:33 +03:00
Tyrrrz	d676b5832e	Fix discrepancies in unicode handling between ConsoleWriter and Console.Write(...)	2021-04-21 03:16:18 +03:00
Tyrrrz	28097afc1e	Update NuGet packages	2021-04-18 19:38:35 +03:00
Tyrrrz	fda96586f3	Update NuGet.config	2021-04-17 21:23:19 +03:00
Tyrrrz	fc5af8dbbc	Don't write default value in help text for types that don't override ToString()	2021-04-16 23:28:39 +03:00
Tyrrrz	4835e64388	Remove GHA workarounds	2021-04-13 22:29:15 +03:00
Tyrrrz	0999c33f93	Add NuGet.config	2021-04-13 22:20:07 +03:00
Tyrrrz	595805255a	Update version	2021-04-09 22:24:06 +03:00
Tyrrrz	65eaa912cf	Refactor	2021-04-08 20:53:48 +03:00
Robert Dailey	038f48b78e	Show choices on non-scalar enum parameters and options (#102 )	2021-04-08 20:51:17 +03:00
Tyrrrz	d7460244b7	Update version	2021-03-31 12:11:50 +03:00
Tyrrrz	02766868fc	Streamline analyzer packaging	2021-03-31 12:11:36 +03:00
Tyrrrz	8d7d25a144	Cleanup	2021-03-31 11:40:37 +03:00
Tyrrrz	17ded54e24	Update readme	2021-03-31 11:29:31 +03:00
Tyrrrz	54a4c32ddf	Fix nullref in SystemConsoleShouldBeAvoidedAnalyzer	2021-03-31 11:28:48 +03:00
Tyrrrz	6d46e82145	Add test for SystemConsoleShouldBeAvoidedAnalyzer for when System.Console isn't used	2021-03-31 00:11:36 +03:00
Tyrrrz	fd4a2a18fe	Improve comment on IConsole.RegisterCancellationHandler()	2021-03-30 16:22:10 +03:00
Tyrrrz	bfe99d620e	Refactor IConsole.WithColors(...)	2021-03-30 16:10:11 +03:00
Tyrrrz	c5a111207f	Seal attributes	2021-03-25 06:01:46 +02:00
Tyrrrz	544945c0e6	Don't reference analyzer assembly from main assembly	2021-03-24 02:42:03 +02:00
Tyrrrz	c616cdd750	Update version	2021-03-24 02:40:10 +02:00
Tyrrrz	d3c396956d	Fix StackFrame.ParseMany(...) being too paranoid about its own failure	2021-03-24 02:34:36 +02:00
Tyrrrz	d0cbbc6d9a	Don't highlight valid values in help text	2021-03-23 01:56:28 +02:00
Tyrrrz	49c7905150	Update version	2021-03-21 18:23:14 +02:00
Tyrrrz	f5a992a16e	Update readme	2021-03-21 18:22:54 +02:00
Tyrrrz	bade0a0048	Extract duplicated code in analyzers	2021-03-21 13:35:38 +02:00
Alexey Golub	7d3d79b861	Refactor (#94 )	2021-03-21 09:54:00 +02:00
Alexey Golub	58df63a7ad	Fix coverage reporting	2021-03-14 21:40:18 +02:00
Alexey Golub	b938eef013	Update readme	2020-12-28 18:39:22 +02:00
Tyrrrz	94f63631db	Use C#9 features	2020-12-14 17:36:46 +02:00
Tyrrrz	90d1b11430	Use floating dotnet version on CI/CD	2020-12-14 17:31:58 +02:00
Tyrrrz	550e54b86d	Update project structure	2020-12-10 16:22:41 +02:00
Tyrrrz	90a01e729b	Update version	2020-12-06 18:42:58 +02:00
Tyrrrz	ac01c2aecb	Allow dashes to appear in parameter values	2020-12-06 18:39:03 +02:00
Tyrrrz	4acffe925c	Revert help text changes in the command section Not happy with how it looks right now. Confusing to the user.	2020-12-06 18:24:30 +02:00
Tyrrrz	18f53eeeef	Simplify gitignore and remove gitattributes	2020-12-06 17:58:02 +02:00
Tyrrrz	03d6942540	Require options to begin with a letter character Fixes #88	2020-11-29 17:14:23 +02:00
Tyrrrz	9be811a89a	Refactor ArgumentValueConverter into a class	2020-11-18 18:37:20 +02:00
Tyrrrz	f9f5a4696b	Add analyzers for invalid validators	2020-11-18 18:26:04 +02:00
Tyrrrz	d6da687170	Refactor recent PRs	2020-11-18 18:00:43 +02:00
Tyrrrz	eba66d0878	Simplify coverage collection	2020-11-11 01:20:08 +02:00
Tyrrrz	8c682766bd	Bump target frameworks on peripheral projects	2020-11-10 23:44:51 +02:00
Tyrrrz	39d626c8d8	Update build infra	2020-11-10 23:30:36 +02:00
Alexey Golub	a338ac8ce2	Custom value validators (#87 )	2020-11-09 17:21:18 +02:00
Oleksandr Shustov	11637127cb	remove redundant space	2020-11-08 20:01:47 +02:00
Oleksandr Shustov	4e12aefafb	add tests	2020-11-07 21:46:32 +02:00
Oleksandr Shustov	144d3592fb	cleanup after merge	2020-11-07 21:34:12 +02:00
Oleksandr Shustov	6f82c2f0f9	merge branch master into feature/custom-validators	2020-11-07 21:18:34 +02:00
Oleksandr Shustov	b8c60717d5	add a base type for custom validators	2020-11-06 20:37:46 +02:00
Rene Escalante	fec6850c39	Change format for the command section in help text (#83 )	2020-10-29 20:31:03 +02:00
Tyrrrz	6a378ad946	Update nuget packages	2020-10-27 17:20:07 +02:00
Tyrrrz	11579f11b1	Update readme	2020-10-25 01:55:12 +03:00
Tyrrrz	60a3b26fd1	Update version	2020-10-23 23:46:57 +03:00
Tyrrrz	3abdfb1acf	Improve child command usage info in help text	2020-10-23 23:36:36 +03:00
Tyrrrz	9557d386e2	Better success check in stack trace parsing	2020-10-23 23:00:29 +03:00
Tyrrrz	d0d024c427	Improve stack trace parsing	2020-10-23 22:57:48 +03:00
Tyrrrz	f765af6061	Update readme with info about custom converters	2020-10-23 22:03:20 +03:00
Tyrrrz	7f2202e869	Cleanup	2020-10-23 21:40:53 +03:00
Tyrrrz	14ad9d5738	Improve tests	2020-10-23 21:18:57 +03:00
Tyrrrz	b120138de3	Update github actions	2020-10-23 20:53:27 +03:00
Tyrrrz	8df1d607c1	Refactor & improve argument conversion feature	2020-10-23 20:52:26 +03:00
Tyrrrz	c06f2810b9	Cleanup analyzers	2020-10-23 18:23:58 +03:00
Tyrrrz	d52a205f13	Improve coverage slightly	2020-10-23 18:17:17 +03:00
Tyrrrz	0ec12e57c1	Refactor pretty stack traces	2020-10-23 18:01:40 +03:00
Nikiforov Alexey	c322b7029c	Add child command usage in help text (#77 )	2020-10-22 16:02:58 +03:00
Oleksandr Shustov	6a38c04c11	Custom value converters (#81 )	2020-10-16 14:22:42 +03:00
Alexey Golub	5e53107def	Treat nullability warnings as errors	2020-10-07 15:20:35 +03:00
Alexey Golub	36cea937de	Update nuget packages	2020-10-07 15:11:37 +03:00
Mårten Åsberg	438d6b98ac	Pretty printing of exception messages (#79 )	2020-10-06 20:43:19 +03:00
Alexey Golub	8e1488c395	Update readme	2020-09-14 22:31:25 +03:00
Alexey Golub	65d321b476	Update readme	2020-08-20 19:31:26 +03:00
Alexey Golub	c6d2359d6b	Update version	2020-08-20 17:02:19 +03:00
Alexey Golub	0d32876bad	Add VirtualConsole.CreateBuffered() for easier testing	2020-08-20 16:27:23 +03:00
Alexey Golub	c063251d89	Exclude some ToString() methods from coverage These are only used for debug information and I'm okayish with them failing at runtime.	2020-08-19 22:39:43 +03:00
Alexey Golub	3831cfc7c0	Get rid of internal tests Move all tests to e2e+ level	2020-08-19 22:31:09 +03:00
Alexey Golub	b17341b56c	Update version	2020-07-31 15:41:47 +03:00
Alexey Golub	5bda964fb5	Cleanup	2020-07-31 15:34:38 +03:00
Daniel Hix	432430489a	Add error for non-scalar parameters bound without any values (#71 )	2020-07-31 15:08:13 +03:00
Ron Myers	9a20101f30	Fix application crashes if there are two environment variables with same name, differing only in case (#67 )	2020-07-28 14:20:02 +03:00
Alexey Golub	b491818779	Update version	2020-07-19 18:20:42 +03:00
Alexey Golub	69c24c8dfc	Refactor	2020-07-19 18:11:54 +03:00
Ihor Nechyporuk	004f906148	Fix exit code overflow for unhandled exceptions on Unix systems (#62 )	2020-07-19 16:50:37 +03:00
Volodymyr Shkolka	ac83233dc2	Add ability to specify active debugger attachment instead of passive (#61 )	2020-07-10 13:54:09 +03:00
Alexey Golub	082910c968	Update readme	2020-05-24 12:46:16 +03:00