Handle breaking changes

Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

.github/FUNDING.yml

@@ -1,3 +0,0 @@
-github: Tyrrrz
-patreon: Tyrrrz
-custom: ['buymeacoffee.com/Tyrrrz', 'tyrrrz.me/donate']

.github/ISSUE_TEMPLATE/bug-report.yml

@@ -0,0 +1,77 @@
+name: 🐛 Bug report
+description: Report broken functionality.
+labels: [bug]
+
+body:
+  - type: markdown
+    attributes:
+      value: |
+        - Avoid generic or vague titles such as "Something's not working" or "A couple of problems" — be as descriptive as possible.
+        - Keep your issue focused on one single problem. If you have multiple bug reports, please create a separate issue for each of them.
+        - Issues should represent **complete and actionable** work items. If you are unsure about something or have a question, please start a [discussion](https://github.com/Tyrrrz/CliFx/discussions/new) instead.
+        - Remember that **CliFx** is an open-source project funded by the community. If you find it useful, **please consider [donating](https://tyrrrz.me/donate) to support its development**.
+
+        ___
+
+  - type: input
+    attributes:
+      label: Version
+      description: Which version of the package does this bug affect? Make sure you're not using an outdated version.
+      placeholder: v1.0.0
+    validations:
+      required: true
+
+  - type: input
+    attributes:
+      label: Platform
+      description: Which platform do you experience this bug on?
+      placeholder: .NET 7.0 / Windows 11
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Steps to reproduce
+      description: >
+        Minimum steps required to reproduce the bug, including prerequisites, code snippets, or other relevant items.
+        The information provided in this field must be readily actionable, meaning that anyone should be able to reproduce the bug by following these steps.
+        If the reproduction steps are too complex to fit in this field, please provide a link to a repository instead.
+      placeholder: |
+        - Step 1
+        - Step 2
+        - Step 3
+    validations:
+      required: true
+
+  - type: textarea
+    attributes:
+      label: Details
+      description: Clear and thorough explanation of the bug, including any additional information you may find relevant.
+      placeholder: |
+        - Expected behavior: ...
+        - Actual behavior: ...
+    validations:
+      required: true
+
+  - type: checkboxes
+    attributes:
+      label: Checklist
+      description: Quick list of checks to ensure that everything is in order.
+      options:
+        - label: I have looked through existing issues to make sure that this bug has not been reported before
+          required: true
+        - label: I have provided a descriptive title for this issue
+          required: true
+        - label: I have made sure that this bug is reproducible on the latest version of the package
+          required: true
+        - label: I have provided all the information needed to reproduce this bug as efficiently as possible
+          required: true
+        - label: I have sponsored this project
+          required: false
+        - label: I have not read any of the above and just checked all the boxes to submit the issue
+          required: false
+
+  - type: markdown
+    attributes:
+      value: |
+        If you are struggling to provide actionable reproduction steps, or if something else is preventing you from creating a complete bug report, please start a [discussion](https://github.com/Tyrrrz/CliFx/discussions/new) instead.

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,11 @@
+blank_issues_enabled: false
+contact_links:
+  - name: ⚠ Feature request
+    url: https://github.com/Tyrrrz/.github/blob/master/docs/project-status.md
+    about: Sorry, but this project is in maintenance mode and no longer accepts new feature requests.
+  - name: 🗨 Discussions
+    url: https://github.com/Tyrrrz/CliFx/discussions/new
+    about: Ask and answer questions.
+  - name: 💬 Discord server
+    url: https://discord.gg/2SUWKFnHSm
+    about: Chat with the project community.

.github/dependabot.yml

@@ -0,0 +1,22 @@
+version: 2
+updates:
+  - package-ecosystem: github-actions
+    directory: "/"
+    schedule:
+      interval: monthly
+    labels:
+      - enhancement
+    groups:
+      actions:
+        patterns:
+          - "*"
+  - package-ecosystem: nuget
+    directory: "/"
+    schedule:
+      interval: monthly
+    labels:
+      - enhancement
+    groups:
+      nuget:
+        patterns:
+          - "*"

.github/workflows/CD.yml

@@ -1,27 +0,0 @@
-name: CD
-
-on:
-  push:
-    tags:
-      - "*"
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2.3.3
-
-      - name: Install .NET
-        uses: actions/setup-dotnet@v1.7.2
-        with:
-          dotnet-version: 5.0.x
-
-      - name: Pack
-        run: |
-          dotnet nuget locals all --clear
-          dotnet pack CliFx --configuration Release
-
-      - name: Deploy
-        run: dotnet nuget push CliFx/bin/Release/*.nupkg -s nuget.org -k ${{ secrets.NUGET_TOKEN }}

.github/workflows/CI.yml

@@ -1,30 +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.3.3
-
-      - name: Install .NET
-        uses: actions/setup-dotnet@v1.7.2
-        with:
-          dotnet-version: 5.0.x
-
-      - name: Build & test
-        run: |
-          dotnet nuget locals all --clear
-          dotnet test --configuration Release --logger GitHubActions
-
-      - name: Upload coverage
-        uses: codecov/codecov-action@v1.0.5
-        with:
-          token: ${{ secrets.CODECOV_TOKEN }}

.github/workflows/main.yml

@@ -0,0 +1,34 @@
+name: main
+
+on:
+  workflow_dispatch:
+    inputs:
+      package-version:
+        type: string
+        description: Package version
+        required: false
+      deploy:
+        type: boolean
+        description: Deploy package
+        required: false
+        default: false
+  push:
+    branches:
+      - master
+    tags:
+      - "*"
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  main:
+    uses: Tyrrrz/.github/.github/workflows/nuget.yml@master
+    with:
+      deploy: ${{ inputs.deploy || github.ref_type == 'tag' }}
+      package-version: ${{ inputs.package-version || (github.ref_type == 'tag' && github.ref_name) || format('0.0.0-ci-{0}', github.sha) }}
+      dotnet-version: 9.0.x
+    secrets:
+      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+      NUGET_TOKEN: ${{ secrets.NUGET_TOKEN }}
+      DISCORD_WEBHOOK: ${{ secrets.DISCORD_WEBHOOK }}

.gitignore

@@ -1,21 +1,12 @@
 # User-specific files
+.vs/
+.idea/
 *.suo
 *.user
-*.userosscache
-*.sln.docstates
-.idea/
 
 # Build results
-[Dd]ebug/
+bin/
-[Dd]ebugPublic/
+obj/
-[Rr]elease/
-[Rr]eleases/
-[Xx]64/
-[Xx]86/
-[Bb]uild/
-bld/
-[Bb]in/
-[Oo]bj/
 
-# Coverage
+# Test results
-*.opencover.xml
+TestResults/

Changelog.md

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

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

@@ -1,11 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net5.0</TargetFramework>
+    <TargetFramework>net9.0</TargetFramework>
-    <IsPackable>false</IsPackable>
-    <IsTestProject>true</IsTestProject>
-    <CollectCoverage>true</CollectCoverage>
-    <CoverletOutputFormat>opencover</CoverletOutputFormat>
   </PropertyGroup>
 
   <ItemGroup>
@@ -13,13 +9,15 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="GitHubActionsTestLogger" Version="1.2.0" />
+    <PackageReference Include="Basic.Reference.Assemblies.Net80" Version="1.8.0" />
-    <PackageReference Include="FluentAssertions" Version="5.10.3" />
+    <PackageReference Include="coverlet.collector" Version="6.0.4" PrivateAssets="all" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.9.1" />
+    <PackageReference Include="CSharpier.MsBuild" Version="0.30.6" PrivateAssets="all" />
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="3.4.0" />
+    <PackageReference Include="GitHubActionsTestLogger" Version="2.4.1" PrivateAssets="all" />
-    <PackageReference Include="xunit" Version="2.4.0" />
+    <PackageReference Include="FluentAssertions" Version="8.0.1" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3" PrivateAssets="all" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
-    <PackageReference Include="coverlet.msbuild" Version="3.0.3" PrivateAssets="all" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.11.0" />
+    <PackageReference Include="xunit" Version="2.9.3" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="3.0.1" PrivateAssets="all" />
   </ItemGroup>
 
   <ItemGroup>

CliFx.Analyzers.Tests/CommandMustBeAnnotatedAnalyzerSpecs.cs

@@ -2,71 +2,74 @@
 using Microsoft.CodeAnalysis.Diagnostics;
 using Xunit;
 
-namespace CliFx.Analyzers.Tests
+namespace CliFx.Analyzers.Tests;
+
+public class CommandMustBeAnnotatedAnalyzerSpecs
 {
-    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()
     {
-        private static DiagnosticAnalyzer Analyzer { get; } = new CommandMustBeAnnotatedAnalyzer();
+        // Arrange
+        // lang=csharp
+        const string code = """
+            public class MyCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
-        [Fact]
+        // Act & assert
-        public void Analyzer_reports_an_error_if_a_command_is_not_annotated_with_the_command_attribute()
+        Analyzer.Should().ProduceDiagnostics(code);
-        {
-            // 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);
-        }
     }
-}
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_command_is_annotated_with_the_command_attribute()
+    {
+        // Arrange
+        // lang=csharp
+        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
+        // lang=csharp
+        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
+        // lang=csharp
+        const string code = """
+            public class Foo
+            {
+                public int Bar { get; init; } = 5;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+}

CliFx.Analyzers.Tests/CommandMustImplementInterfaceAnalyzerSpecs.cs

@@ -2,57 +2,60 @@
 using Microsoft.CodeAnalysis.Diagnostics;
 using Xunit;
 
-namespace CliFx.Analyzers.Tests
+namespace CliFx.Analyzers.Tests;
+
+public class CommandMustImplementInterfaceAnalyzerSpecs
 {
-    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()
     {
-        private static DiagnosticAnalyzer Analyzer { get; } = new CommandMustImplementInterfaceAnalyzer();
+        // Arrange
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand
+            {
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
-        [Fact]
+        // Act & assert
-        public void Analyzer_reports_an_error_if_a_command_does_not_implement_ICommand_interface()
+        Analyzer.Should().ProduceDiagnostics(code);
-        {
-            // 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);
-        }
     }
-}
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_command_implements_ICommand_interface()
+    {
+        // Arrange
+        // lang=csharp
+        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
+        // lang=csharp
+        const string code = """
+            public class Foo
+            {
+                public int Bar { get; init; } = 5;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+}

CliFx.Analyzers.Tests/GeneralSpecs.cs

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

CliFx.Analyzers.Tests/OptionMustBeInsideCommandAnalyzerSpecs.cs

@@ -2,79 +2,82 @@
 using Microsoft.CodeAnalysis.Diagnostics;
 using Xunit;
 
-namespace CliFx.Analyzers.Tests
+namespace CliFx.Analyzers.Tests;
+
+public class OptionMustBeInsideCommandAnalyzerSpecs
 {
-    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()
     {
-        private static DiagnosticAnalyzer Analyzer { get; } = new OptionMustBeInsideCommandAnalyzer();
+        // Arrange
+        // lang=csharp
+        const string code = """
+            public class MyClass
+            {
+                [CommandOption("foo")]
+                public string? Foo { get; init; }
+            }
+            """;
 
-        [Fact]
+        // Act & assert
-        public void Analyzer_reports_an_error_if_an_option_is_inside_a_class_that_is_not_a_command()
+        Analyzer.Should().ProduceDiagnostics(code);
-        {
-            // 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);
-        }
     }
-}
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_an_option_is_inside_a_command()
+    {
+        // Arrange
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("foo")]
+                public string? Foo { get; init; }
+
+                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
+        // lang=csharp
+        const string code = """
+            public abstract class MyCommand
+            {
+                [CommandOption("foo")]
+                public string? Foo { get; init; }
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_on_a_property_that_is_not_an_option()
+    {
+        // Arrange
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public string? Foo { get; init; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+}

CliFx.Analyzers.Tests/OptionMustBeRequiredIfPropertyRequiredAnalyzerSpecs.cs

@@ -0,0 +1,110 @@
+using CliFx.Analyzers.Tests.Utils;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Xunit;
+
+namespace CliFx.Analyzers.Tests;
+
+public class OptionMustBeRequiredIfPropertyRequiredAnalyzerSpecs
+{
+    private static DiagnosticAnalyzer Analyzer { get; } =
+        new OptionMustBeRequiredIfPropertyRequiredAnalyzer();
+
+    [Fact]
+    public void Analyzer_reports_an_error_if_a_non_required_option_is_bound_to_a_required_property()
+    {
+        // Arrange
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption('f', IsRequired = false)]
+                public required string Foo { get; init; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_required_option_is_bound_to_a_required_property()
+    {
+        // Arrange
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption('f')]
+                public required string Foo { get; init; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_non_required_option_is_bound_to_a_non_required_property()
+    {
+        // Arrange
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption('f', IsRequired = false)]
+                public string? Foo { get; init; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_required_option_is_bound_to_a_non_required_property()
+    {
+        // Arrange
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption('f')]
+                public required string Foo { get; init; }
+
+                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
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public required string Foo { get; init; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+}

CliFx.Analyzers.Tests/OptionMustHaveNameOrShortNameAnalyzerSpecs.cs

@@ -2,85 +2,89 @@
 using Microsoft.CodeAnalysis.Diagnostics;
 using Xunit;
 
-namespace CliFx.Analyzers.Tests
+namespace CliFx.Analyzers.Tests;
+
+public class OptionMustHaveNameOrShortNameAnalyzerSpecs
 {
-    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()
     {
-        private static DiagnosticAnalyzer Analyzer { get; } = new OptionMustHaveNameOrShortNameAnalyzer();
+        // Arrange
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption(null)]
+                public string? Foo { get; init; }
 
-        [Fact]
+                public ValueTask ExecuteAsync(IConsole console) => default;
-        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
+        // Act & assert
-            Analyzer.Should().ProduceDiagnostics(code);
+        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);
-        }
     }
-}
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_an_option_has_a_name()
+    {
+        // Arrange
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("foo")]
+                public string? Foo { get; init; }
+
+                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
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption('f')]
+                public string? Foo { get; init; }
+
+                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
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public string? Foo { get; init; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+}

CliFx.Analyzers.Tests/OptionMustHaveUniqueNameAnalyzerSpecs.cs

@@ -2,91 +2,94 @@
 using Microsoft.CodeAnalysis.Diagnostics;
 using Xunit;
 
-namespace CliFx.Analyzers.Tests
+namespace CliFx.Analyzers.Tests;
+
+public class OptionMustHaveUniqueNameAnalyzerSpecs
 {
-    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()
     {
-        private static DiagnosticAnalyzer Analyzer { get; } = new OptionMustHaveUniqueNameAnalyzer();
+        // Arrange
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("foo")]
+                public string? Foo { get; init; }
 
-        [Fact]
+                [CommandOption("foo")]
-        public void Analyzer_reports_an_error_if_an_option_has_the_same_name_as_another_option()
+                public string? Bar { get; init; }
-        {
-            // 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;
+                public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
-            // Act & assert
+        // Act & assert
-            Analyzer.Should().ProduceDiagnostics(code);
+        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);
-        }
     }
-}
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_an_option_has_a_unique_name()
+    {
+        // Arrange
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("foo")]
+                public string? Foo { get; init; }
+
+                [CommandOption("bar")]
+                public string? Bar { get; init; }
+
+                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
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption('f')]
+                public string? Foo { get; init; }
+
+                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
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public string? Foo { get; init; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+}

CliFx.Analyzers.Tests/OptionMustHaveUniqueShortNameAnalyzerSpecs.cs

@@ -2,113 +2,118 @@
 using Microsoft.CodeAnalysis.Diagnostics;
 using Xunit;
 
-namespace CliFx.Analyzers.Tests
+namespace CliFx.Analyzers.Tests;
+
+public class OptionMustHaveUniqueShortNameAnalyzerSpecs
 {
-    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()
     {
-        private static DiagnosticAnalyzer Analyzer { get; } = new OptionMustHaveUniqueShortNameAnalyzer();
+        // Arrange
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption('f')]
+                public string? Foo { get; init; }
 
-        [Fact]
+                [CommandOption('f')]
-        public void Analyzer_reports_an_error_if_an_option_has_the_same_short_name_as_another_option()
+                public string? Bar { get; init; }
-        {
-            // 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;
+                public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
-            // Act & assert
+        // Act & assert
-            Analyzer.Should().ProduceDiagnostics(code);
+        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);
-        }
     }
-}
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_an_option_has_a_unique_short_name()
+    {
+        // Arrange
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption('f')]
+                public string? Foo { get; init; }
+
+                [CommandOption('b')]
+                public string? Bar { get; init; }
+
+                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
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption('f')]
+                public string? Foo { get; init; }
+
+                [CommandOption('F')]
+                public string? Bar { get; init; }
+
+                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
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("foo")]
+                public string? Foo { get; init; }
+
+                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
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public string? Foo { get; init; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+}

CliFx.Analyzers.Tests/OptionMustHaveValidConverterAnalyzerSpecs.cs

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

CliFx.Analyzers.Tests/OptionMustHaveValidNameAnalyzerSpecs.cs

@@ -2,104 +2,108 @@
 using Microsoft.CodeAnalysis.Diagnostics;
 using Xunit;
 
-namespace CliFx.Analyzers.Tests
+namespace CliFx.Analyzers.Tests;
+
+public class OptionMustHaveValidNameAnalyzerSpecs
 {
-    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()
     {
-        private static DiagnosticAnalyzer Analyzer { get; } = new OptionMustHaveValidNameAnalyzer();
+        // Arrange
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("f")]
+                public string? Foo { get; init; }
 
-        [Fact]
+                public ValueTask ExecuteAsync(IConsole console) => default;
-        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
+        // Act & assert
-            Analyzer.Should().ProduceDiagnostics(code);
+        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);
-        }
     }
-}
+
+    [Fact]
+    public void Analyzer_reports_an_error_if_an_option_has_a_name_that_starts_with_a_non_letter_character()
+    {
+        // Arrange
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("1foo")]
+                public string? Foo { get; init; }
+
+                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
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("foo")]
+                public string? Foo { get; init; }
+
+                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
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption('f')]
+                public string? Foo { get; init; }
+
+                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
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public string? Foo { get; init; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+}

CliFx.Analyzers.Tests/OptionMustHaveValidShortNameAnalyzerSpecs.cs

@@ -2,85 +2,89 @@
 using Microsoft.CodeAnalysis.Diagnostics;
 using Xunit;
 
-namespace CliFx.Analyzers.Tests
+namespace CliFx.Analyzers.Tests;
+
+public class OptionMustHaveValidShortNameAnalyzerSpecs
 {
-    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()
     {
-        private static DiagnosticAnalyzer Analyzer { get; } = new OptionMustHaveValidShortNameAnalyzer();
+        // Arrange
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption('1')]
+                public string? Foo { get; init; }
 
-        [Fact]
+                public ValueTask ExecuteAsync(IConsole console) => default;
-        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
+        // Act & assert
-            Analyzer.Should().ProduceDiagnostics(code);
+        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);
-        }
     }
-}
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_an_option_has_a_valid_short_name()
+    {
+        // Arrange
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption('f')]
+                public string? Foo { get; init; }
+
+                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
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("foo")]
+                public string? Foo { get; init; }
+
+                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
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public string? Foo { get; init; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+}

CliFx.Analyzers.Tests/OptionMustHaveValidValidatorsAnalyzerSpecs.cs

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

CliFx.Analyzers.Tests/ParameterMustBeInsideCommandAnalyzerSpecs.cs

@@ -2,79 +2,83 @@
 using Microsoft.CodeAnalysis.Diagnostics;
 using Xunit;
 
-namespace CliFx.Analyzers.Tests
+namespace CliFx.Analyzers.Tests;
+
+public class ParameterMustBeInsideCommandAnalyzerSpecs
 {
-    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()
     {
-        private static DiagnosticAnalyzer Analyzer { get; } = new ParameterMustBeInsideCommandAnalyzer();
+        // Arrange
+        // lang=csharp
+        const string code = """
+            public class MyClass
+            {
+                [CommandParameter(0)]
+                public required string Foo { get; init; }
+            }
+            """;
 
-        [Fact]
+        // Act & assert
-        public void Analyzer_reports_an_error_if_a_parameter_is_inside_a_class_that_is_not_a_command()
+        Analyzer.Should().ProduceDiagnostics(code);
-        {
-            // 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);
-        }
     }
-}
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_parameter_is_inside_a_command()
+    {
+        // Arrange
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0)]
+                public required string Foo { get; init; }
+
+                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
+        // lang=csharp
+        const string code = """
+            public abstract class MyCommand
+            {
+                [CommandParameter(0)]
+                public required string Foo { get; init; }
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_on_a_property_that_is_not_a_parameter()
+    {
+        // Arrange
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public string? Foo { get; init; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+}

CliFx.Analyzers.Tests/ParameterMustBeLastIfNonRequiredAnalyzerSpecs.cs

@@ -0,0 +1,99 @@
+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
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0, IsRequired = false)]
+                public string? Foo { get; init; }
+
+                [CommandParameter(1)]
+                public required string Bar { get; init; }
+
+                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
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0)]
+                public required string Foo { get; init; }
+
+                [CommandParameter(1, IsRequired = false)]
+                public string? Bar { get; init; }
+
+                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
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0)]
+                public required string Foo { get; init; }
+
+                [CommandParameter(1)]
+                public required string Bar { get; init; }
+
+                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
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public string? Foo { get; init; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+}

CliFx.Analyzers.Tests/ParameterMustBeLastIfNonScalarAnalyzerSpecs.cs

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

CliFx.Analyzers.Tests/ParameterMustBeRequiredIfPropertyRequiredAnalyzerSpecs.cs

@@ -0,0 +1,110 @@
+using CliFx.Analyzers.Tests.Utils;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Xunit;
+
+namespace CliFx.Analyzers.Tests;
+
+public class ParameterMustBeRequiredIfPropertyRequiredAnalyzerSpecs
+{
+    private static DiagnosticAnalyzer Analyzer { get; } =
+        new ParameterMustBeRequiredIfPropertyRequiredAnalyzer();
+
+    [Fact]
+    public void Analyzer_reports_an_error_if_a_non_required_parameter_is_bound_to_a_required_property()
+    {
+        // Arrange
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0, IsRequired = false)]
+                public required string? Foo { get; init; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_required_parameter_is_bound_to_a_required_property()
+    {
+        // Arrange
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0)]
+                public required string Foo { get; init; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_non_required_parameter_is_bound_to_a_non_required_property()
+    {
+        // Arrange
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0, IsRequired = false)]
+                public string? Foo { get; init; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_required_parameter_is_bound_to_a_non_required_property()
+    {
+        // Arrange
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0)]
+                public required string Foo { get; init; }
+
+                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
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public required string Foo { get; init; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+}

CliFx.Analyzers.Tests/ParameterMustBeSingleIfNonRequiredAnalyzerSpecs.cs

@@ -0,0 +1,99 @@
+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
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0, IsRequired = false)]
+                public string? Foo { get; init; }
+
+                [CommandParameter(1, IsRequired = false)]
+                public string? Bar { get; init; }
+
+                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
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0)]
+                public required string Foo { get; init; }
+
+                [CommandParameter(1, IsRequired = false)]
+                public string? Bar { get; init; }
+
+                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
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0)]
+                public required string Foo { get; init; }
+
+                [CommandParameter(1)]
+                public required string Bar { get; init; }
+
+                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
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public string? Foo { get; init; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+}

CliFx.Analyzers.Tests/ParameterMustBeSingleIfNonScalarAnalyzerSpecs.cs

@@ -2,94 +2,98 @@
 using Microsoft.CodeAnalysis.Diagnostics;
 using Xunit;
 
-namespace CliFx.Analyzers.Tests
+namespace CliFx.Analyzers.Tests;
+
+public class ParameterMustBeSingleIfNonScalarAnalyzerSpecs
 {
-    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()
     {
-        private static DiagnosticAnalyzer Analyzer { get; } = new ParameterMustBeSingleIfNonScalarAnalyzer();
+        // Arrange
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0)]
+                public required string[] Foo { get; init; }
 
-        [Fact]
+                [CommandParameter(1)]
-        public void Analyzer_reports_an_error_if_more_than_one_non_scalar_parameters_are_defined()
+                public required string[] Bar { get; init; }
-        {
-            // 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;
+                public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
-            // Act & assert
+        // Act & assert
-            Analyzer.Should().ProduceDiagnostics(code);
+        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);
-        }
     }
-}
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_only_one_non_scalar_parameter_is_defined()
+    {
+        // Arrange
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0)]
+                public required string Foo { get; init; }
+
+                [CommandParameter(1)]
+                public required string[] Bar { get; init; }
+
+                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
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0)]
+                public required string Foo { get; init; }
+
+                [CommandParameter(1)]
+                public required string Bar { get; init; }
+
+                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
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public string? Foo { get; init; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+}

CliFx.Analyzers.Tests/ParameterMustHaveUniqueNameAnalyzerSpecs.cs

@@ -2,72 +2,74 @@
 using Microsoft.CodeAnalysis.Diagnostics;
 using Xunit;
 
-namespace CliFx.Analyzers.Tests
+namespace CliFx.Analyzers.Tests;
+
+public class ParameterMustHaveUniqueNameAnalyzerSpecs
 {
-    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()
     {
-        private static DiagnosticAnalyzer Analyzer { get; } = new ParameterMustHaveUniqueNameAnalyzer();
+        // Arrange
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0, Name = "foo")]
+                public required string Foo { get; init; }
 
-        [Fact]
+                [CommandParameter(1, Name = "foo")]
-        public void Analyzer_reports_an_error_if_a_parameter_has_the_same_name_as_another_parameter()
+                public required string Bar { get; init; }
-        {
-            // 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;
+                public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
-            // Act & assert
+        // Act & assert
-            Analyzer.Should().ProduceDiagnostics(code);
+        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);
-        }
     }
-}
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_parameter_has_unique_name()
+    {
+        // Arrange
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0, Name = "foo")]
+                public required string Foo { get; init; }
+
+                [CommandParameter(1, Name = "bar")]
+                public required string Bar { get; init; }
+
+                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
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public string? Foo { get; init; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+}

CliFx.Analyzers.Tests/ParameterMustHaveUniqueOrderAnalyzerSpecs.cs

@@ -2,72 +2,75 @@
 using Microsoft.CodeAnalysis.Diagnostics;
 using Xunit;
 
-namespace CliFx.Analyzers.Tests
+namespace CliFx.Analyzers.Tests;
+
+public class ParameterMustHaveUniqueOrderAnalyzerSpecs
 {
-    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()
     {
-        private static DiagnosticAnalyzer Analyzer { get; } = new ParameterMustHaveUniqueOrderAnalyzer();
+        // Arrange
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0)]
+                public required string Foo { get; init; }
 
-        [Fact]
+                [CommandParameter(0)]
-        public void Analyzer_reports_an_error_if_a_parameter_has_the_same_order_as_another_parameter()
+                public required string Bar { get; init; }
-        {
-            // 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;
+                public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
-            // Act & assert
+        // Act & assert
-            Analyzer.Should().ProduceDiagnostics(code);
+        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);
-        }
     }
-}
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_parameter_has_unique_order()
+    {
+        // Arrange
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0)]
+                public required string Foo { get; init; }
+
+                [CommandParameter(1)]
+                public required string Bar { get; init; }
+
+                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
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public string? Foo { get; init; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+}

CliFx.Analyzers.Tests/ParameterMustHaveValidConverterAnalyzerSpecs.cs

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

CliFx.Analyzers.Tests/ParameterMustHaveValidValidatorsAnalyzerSpecs.cs

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

CliFx.Analyzers.Tests/SystemConsoleShouldBeAvoidedAnalyzerSpecs.cs

@@ -2,107 +2,133 @@
 using Microsoft.CodeAnalysis.Diagnostics;
 using Xunit;
 
-namespace CliFx.Analyzers.Tests
+namespace CliFx.Analyzers.Tests;
+
+public class SystemConsoleShouldBeAvoidedAnalyzerSpecs
 {
-    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()
     {
-        private static DiagnosticAnalyzer Analyzer { get; } = new SystemConsoleShouldBeAvoidedAnalyzer();
+        // Arrange
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    Console.WriteLine("Hello world");
+                    return default;
+                }
+            }
+            """;
 
-        [Fact]
+        // Act & assert
-        public void Analyzer_reports_an_error_if_a_command_calls_a_method_on_SystemConsole()
+        Analyzer.Should().ProduceDiagnostics(code);
-        {
+    }
-            // Arrange
+
-            // language=cs
+    [Fact]
-            const string code = @"
+    public void Analyzer_reports_an_error_if_a_command_accesses_a_property_on_SystemConsole()
-[Command]
-public class MyCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console)
     {
-        Console.WriteLine(""Hello world"");
+        // Arrange
-        return default;
+        // lang=csharp
+        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);
     }
-}";
 
-            // Act & assert
+    [Fact]
-            Analyzer.Should().ProduceDiagnostics(code);
+    public void Analyzer_reports_an_error_if_a_command_calls_a_method_on_a_property_of_SystemConsole()
-        }
-
-        [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;
+        // Arrange
-        return default;
+        // lang=csharp
-    }
+        const string code = """
-}";
+            [Command]
-            // Act & assert
+            public class MyCommand : ICommand
-            Analyzer.Should().ProduceDiagnostics(code);
+            {
-        }
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    Console.Error.WriteLine("Hello world");
+                    return default;
+                }
+            }
+            """;
 
-        [Fact]
+        // Act & assert
-        public void Analyzer_reports_an_error_if_a_command_calls_a_method_on_a_property_of_SystemConsole()
+        Analyzer.Should().ProduceDiagnostics(code);
-        {
+    }
-            // Arrange
+
-            // language=cs
+    [Fact]
-            const string code = @"
+    public void Analyzer_does_not_report_an_error_if_a_command_interacts_with_the_console_through_IConsole()
-[Command]
-public class MyCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console)
     {
-        Console.Error.WriteLine(""Hello world"");
+        // Arrange
-        return default;
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.WriteLine("Hello world");
+                    return default;
+                }
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
     }
-}";
 
-            // Act & assert
+    [Fact]
-            Analyzer.Should().ProduceDiagnostics(code);
+    public void Analyzer_does_not_report_an_error_if_IConsole_is_not_available_in_the_current_method()
-        }
-
-        [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"");
+        // Arrange
-        return default;
+        // lang=csharp
+        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);
     }
-}";
 
-            // Act & assert
+    [Fact]
-            Analyzer.Should().NotProduceDiagnostics(code);
+    public void Analyzer_does_not_report_an_error_if_a_command_does_not_access_SystemConsole()
-        }
+    {
+        // Arrange
+        // lang=csharp
+        const string code = """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    return default;
+                }
+            }
+            """;
 
-        [Fact]
+        // Act & assert
-        public void Analyzer_does_not_report_an_error_if_IConsole_is_not_available_in_the_current_method()
+        Analyzer.Should().NotProduceDiagnostics(code);
-        {
-            // Arrange
-            // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    public void SomeOtherMethod() => Console.WriteLine(""Test"");
-
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
-
-            // Act & assert
-            Analyzer.Should().NotProduceDiagnostics(code);
-        }
     }
-}
+}

CliFx.Analyzers.Tests/Utils/AnalyzerAssertions.cs

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

CliFx.Analyzers/AnalyzerBase.cs

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

CliFx.Analyzers/CliFx.Analyzers.csproj

@@ -2,12 +2,26 @@
 
   <PropertyGroup>
     <TargetFramework>netstandard2.0</TargetFramework>
-    <Nullable>annotations</Nullable>
+    <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
+    <GenerateDependencyFile>true</GenerateDependencyFile>
+    <EnforceExtendedAnalyzerRules>true</EnforceExtendedAnalyzerRules>
     <NoWarn>$(NoWarn);RS1025;RS1026</NoWarn>
   </PropertyGroup>
 
+  <PropertyGroup>
+    <!--
+      Because this project only has a single target framework, the condition in
+      Directory.Build.props does not appear to work. This is a workaround for that.
+    -->
+    <Nullable>annotations</Nullable>
+  </PropertyGroup>
+
   <ItemGroup>
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="3.4.0" PrivateAssets="all" />
+    <PackageReference Include="CSharpier.MsBuild" Version="0.30.6" PrivateAssets="all" />
+    <!-- Make sure to target the lowest possible version of the compiler for wider support -->
+    <PackageReference Include="Microsoft.CodeAnalysis" Version="3.0.0" PrivateAssets="all" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="3.0.0" PrivateAssets="all" />
+    <PackageReference Include="PolyShim" Version="1.14.0" PrivateAssets="all" />
   </ItemGroup>
 
 </Project>

CliFx.Analyzers/CommandMustBeAnnotatedAnalyzer.cs

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

CliFx.Analyzers/CommandMustImplementInterfaceAnalyzer.cs

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

CliFx.Analyzers/ObjectModel/CommandOptionSymbol.cs

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

CliFx.Analyzers/ObjectModel/CommandParameterSymbol.cs

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

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

CliFx.Analyzers/ObjectModel/SymbolNames.cs

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

CliFx.Analyzers/OptionMustBeInsideCommandAnalyzer.cs

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

CliFx.Analyzers/OptionMustBeRequiredIfPropertyRequiredAnalyzer.cs

@@ -0,0 +1,43 @@
+using CliFx.Analyzers.ObjectModel;
+using CliFx.Analyzers.Utils.Extensions;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace CliFx.Analyzers;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public class OptionMustBeRequiredIfPropertyRequiredAnalyzer()
+    : AnalyzerBase(
+        "Options bound to required properties cannot be marked as non-required",
+        "This option cannot be marked as non-required because it's bound to a required property."
+    )
+{
+    private void Analyze(
+        SyntaxNodeAnalysisContext context,
+        PropertyDeclarationSyntax propertyDeclaration,
+        IPropertySymbol property
+    )
+    {
+        if (property.ContainingType is null)
+            return;
+
+        if (!property.IsRequired())
+            return;
+
+        var option = CommandOptionSymbol.TryResolve(property);
+        if (option is null)
+            return;
+
+        if (option.IsRequired != false)
+            return;
+
+        context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.Identifier.GetLocation()));
+    }
+
+    public override void Initialize(AnalysisContext context)
+    {
+        base.Initialize(context);
+        context.HandlePropertyDeclaration(Analyze);
+    }
+}

CliFx.Analyzers/OptionMustHaveNameOrShortNameAnalyzer.cs

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

CliFx.Analyzers/OptionMustHaveUniqueNameAnalyzer.cs

@@ -6,57 +6,64 @@ using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 
-namespace CliFx.Analyzers
+namespace CliFx.Analyzers;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public class OptionMustHaveUniqueNameAnalyzer()
+    : AnalyzerBase(
+        "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}`."
+    )
 {
-    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    private void Analyze(
-    public class OptionMustHaveUniqueNameAnalyzer : AnalyzerBase
+        SyntaxNodeAnalysisContext context,
+        PropertyDeclarationSyntax propertyDeclaration,
+        IPropertySymbol property
+    )
     {
-        public OptionMustHaveUniqueNameAnalyzer()
+        if (property.ContainingType is null)
-            : base(
+            return;
-                "Options must have unique names",
+
-                "This option's name must be unique within the command (comparison IS NOT case sensitive).")
+        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))
+            .ToArray();
+
+        foreach (var otherProperty in otherProperties)
         {
-        }
+            var otherOption = CommandOptionSymbol.TryResolve(otherProperty);
+            if (otherOption is null)
+                continue;
 
-        private void Analyze(
+            if (string.IsNullOrWhiteSpace(otherOption.Name))
-            SyntaxNodeAnalysisContext context,
+                continue;
-            PropertyDeclarationSyntax propertyDeclaration,
-            IPropertySymbol property)
-        {
-            var option = CommandOptionSymbol.TryResolve(property);
-            if (option is null)
-                return;
 
-            if (string.IsNullOrWhiteSpace(option.Name))
+            if (string.Equals(option.Name, otherOption.Name, StringComparison.OrdinalIgnoreCase))
-                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);
+                context.ReportDiagnostic(
-                if (otherOption is null)
+                    CreateDiagnostic(
-                    continue;
+                        propertyDeclaration.Identifier.GetLocation(),
-
+                        option.Name,
-                if (string.IsNullOrWhiteSpace(otherOption.Name))
+                        otherProperty.Name
-                    continue;
+                    )
-
+                );
-                if (string.Equals(option.Name, otherOption.Name, StringComparison.OrdinalIgnoreCase))
-                {
-                    context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
-                }
             }
         }
-
-        public override void Initialize(AnalysisContext context)
-        {
-            base.Initialize(context);
-            context.HandlePropertyDeclaration(Analyze);
-        }
     }
-}
+
+    public override void Initialize(AnalysisContext context)
+    {
+        base.Initialize(context);
+        context.HandlePropertyDeclaration(Analyze);
+    }
+}

CliFx.Analyzers/OptionMustHaveUniqueShortNameAnalyzer.cs

@@ -5,57 +5,64 @@ using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 
-namespace CliFx.Analyzers
+namespace CliFx.Analyzers;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public class OptionMustHaveUniqueShortNameAnalyzer()
+    : AnalyzerBase(
+        "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}`."
+    )
 {
-    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    private void Analyze(
-    public class OptionMustHaveUniqueShortNameAnalyzer : AnalyzerBase
+        SyntaxNodeAnalysisContext context,
+        PropertyDeclarationSyntax propertyDeclaration,
+        IPropertySymbol property
+    )
     {
-        public OptionMustHaveUniqueShortNameAnalyzer()
+        if (property.ContainingType is null)
-            : base(
+            return;
-                "Options must have unique short names",
+
-                "This option's short name must be unique within the command (comparison IS case sensitive).")
+        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))
+            .ToArray();
+
+        foreach (var otherProperty in otherProperties)
         {
-        }
+            var otherOption = CommandOptionSymbol.TryResolve(otherProperty);
+            if (otherOption is null)
+                continue;
 
-        private void Analyze(
+            if (otherOption.ShortName is null)
-            SyntaxNodeAnalysisContext context,
+                continue;
-            PropertyDeclarationSyntax propertyDeclaration,
-            IPropertySymbol property)
-        {
-            var option = CommandOptionSymbol.TryResolve(property);
-            if (option is null)
-                return;
 
-            if (option.ShortName is null)
+            if (option.ShortName == otherOption.ShortName)
-                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);
+                context.ReportDiagnostic(
-                if (otherOption is null)
+                    CreateDiagnostic(
-                    continue;
+                        propertyDeclaration.Identifier.GetLocation(),
-
+                        option.ShortName,
-                if (otherOption.ShortName is null)
+                        otherProperty.Name
-                    continue;
+                    )
-
+                );
-                if (option.ShortName == otherOption.ShortName)
-                {
-                    context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
-                }
             }
         }
-
-        public override void Initialize(AnalysisContext context)
-        {
-            base.Initialize(context);
-            context.HandlePropertyDeclaration(Analyze);
-        }
     }
-}
+
+    public override void Initialize(AnalysisContext context)
+    {
+        base.Initialize(context);
+        context.HandlePropertyDeclaration(Analyze);
+    }
+}

CliFx.Analyzers/OptionMustHaveValidConverterAnalyzer.cs

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

CliFx.Analyzers/OptionMustHaveValidNameAnalyzer.cs

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

CliFx.Analyzers/OptionMustHaveValidShortNameAnalyzer.cs

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

CliFx.Analyzers/OptionMustHaveValidValidatorsAnalyzer.cs

@@ -5,48 +5,54 @@ using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 
-namespace CliFx.Analyzers
+namespace CliFx.Analyzers;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public class OptionMustHaveValidValidatorsAnalyzer()
+    : AnalyzerBase(
+        $"Option validators must derive from `{SymbolNames.CliFxBindingValidatorClass}`",
+        $"Each validator specified for this option must derive from a compatible `{SymbolNames.CliFxBindingValidatorClass}`."
+    )
 {
-    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    private void Analyze(
-    public class OptionMustHaveValidValidatorsAnalyzer : AnalyzerBase
+        SyntaxNodeAnalysisContext context,
+        PropertyDeclarationSyntax propertyDeclaration,
+        IPropertySymbol property
+    )
     {
-        public OptionMustHaveValidValidatorsAnalyzer()
+        var option = CommandOptionSymbol.TryResolve(property);
-            : base(
+        if (option is null)
-                $"Option validators must derive from `{SymbolNames.CliFxBindingValidatorClass}`",
+            return;
-                $"All validators specified for this option must derive from `{SymbolNames.CliFxBindingValidatorClass}`.")
-        {
-        }
 
-        private void Analyze(
+        foreach (var validatorType in option.ValidatorTypes)
-            SyntaxNodeAnalysisContext context,
-            PropertyDeclarationSyntax propertyDeclaration,
-            IPropertySymbol property)
         {
-            var option = CommandOptionSymbol.TryResolve(property);
+            var validatorValueType = validatorType
-            if (option is null)
+                .GetBaseTypes()
-                return;
+                .FirstOrDefault(t =>
+                    t.ConstructedFrom.DisplayNameMatches(SymbolNames.CliFxBindingValidatorClass)
+                )
+                ?.TypeArguments.FirstOrDefault();
 
-            foreach (var validatorType in option.ValidatorTypes)
+            // 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)
             {
-                // We check against an internal interface because checking against a generic class is a pain
+                context.ReportDiagnostic(
-                var validatorImplementsInterface = validatorType
+                    CreateDiagnostic(propertyDeclaration.Identifier.GetLocation())
-                    .AllInterfaces
+                );
-                    .Any(s => s.DisplayNameMatches(SymbolNames.CliFxBindingValidatorInterface));
 
-                if (!validatorImplementsInterface)
+                // No need to report multiple identical diagnostics on the same node
-                {
+                break;
-                    context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
-
-                    // No need to report multiple identical diagnostics on the same node
-                    break;
-                }
             }
         }
-
-        public override void Initialize(AnalysisContext context)
-        {
-            base.Initialize(context);
-            context.HandlePropertyDeclaration(Analyze);
-        }
     }
-}
+
+    public override void Initialize(AnalysisContext context)
+    {
+        base.Initialize(context);
+        context.HandlePropertyDeclaration(Analyze);
+    }
+}

CliFx.Analyzers/ParameterMustBeInsideCommandAnalyzer.cs

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

CliFx.Analyzers/ParameterMustBeLastIfNonRequiredAnalyzer.cs

@@ -0,0 +1,63 @@
+using System.Linq;
+using CliFx.Analyzers.ObjectModel;
+using CliFx.Analyzers.Utils.Extensions;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace CliFx.Analyzers;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public class ParameterMustBeLastIfNonRequiredAnalyzer()
+    : AnalyzerBase(
+        "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))
+            .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);
+    }
+}

CliFx.Analyzers/ParameterMustBeLastIfNonScalarAnalyzer.cs

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

CliFx.Analyzers/ParameterMustBeRequiredIfPropertyRequiredAnalyzer.cs

@@ -0,0 +1,43 @@
+using CliFx.Analyzers.ObjectModel;
+using CliFx.Analyzers.Utils.Extensions;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace CliFx.Analyzers;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public class ParameterMustBeRequiredIfPropertyRequiredAnalyzer()
+    : AnalyzerBase(
+        "Parameters bound to required properties cannot be marked as non-required",
+        "This parameter cannot be marked as non-required because it's bound to a required property."
+    )
+{
+    private void Analyze(
+        SyntaxNodeAnalysisContext context,
+        PropertyDeclarationSyntax propertyDeclaration,
+        IPropertySymbol property
+    )
+    {
+        if (property.ContainingType is null)
+            return;
+
+        if (!property.IsRequired())
+            return;
+
+        var parameter = CommandParameterSymbol.TryResolve(property);
+        if (parameter is null)
+            return;
+
+        if (parameter.IsRequired != false)
+            return;
+
+        context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.Identifier.GetLocation()));
+    }
+
+    public override void Initialize(AnalysisContext context)
+    {
+        base.Initialize(context);
+        context.HandlePropertyDeclaration(Analyze);
+    }
+}

CliFx.Analyzers/ParameterMustBeSingleIfNonRequiredAnalyzer.cs

@@ -0,0 +1,63 @@
+using System.Linq;
+using CliFx.Analyzers.ObjectModel;
+using CliFx.Analyzers.Utils.Extensions;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace CliFx.Analyzers;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public class ParameterMustBeSingleIfNonRequiredAnalyzer()
+    : AnalyzerBase(
+        "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))
+            .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);
+    }
+}

CliFx.Analyzers/ParameterMustBeSingleIfNonScalarAnalyzer.cs

@@ -5,59 +5,59 @@ using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 
-namespace CliFx.Analyzers
+namespace CliFx.Analyzers;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public class ParameterMustBeSingleIfNonScalarAnalyzer()
+    : AnalyzerBase(
+        "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}`."
+    )
 {
-    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    private void Analyze(
-    public class ParameterMustBeSingleIfNonScalarAnalyzer : AnalyzerBase
+        SyntaxNodeAnalysisContext context,
+        PropertyDeclarationSyntax propertyDeclaration,
+        IPropertySymbol property
+    )
     {
-        public ParameterMustBeSingleIfNonScalarAnalyzer()
+        if (property.ContainingType is null)
-            : base(
+            return;
-                "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.")
+        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))
+            .ToArray();
+
+        foreach (var otherProperty in otherProperties)
         {
-        }
+            var otherParameter = CommandParameterSymbol.TryResolve(otherProperty);
+            if (otherParameter is null)
+                continue;
 
-        private static bool IsScalar(ITypeSymbol type) =>
+            if (!otherParameter.IsScalar())
-            type.DisplayNameMatches("string") ||
-            type.DisplayNameMatches("System.String") ||
-            !type.AllInterfaces
-                .Select(i => i.ConstructedFrom)
-                .Any(s => s.DisplayNameMatches("System.Collections.Generic.IEnumerable<T>"));
-
-        private void Analyze(
-            SyntaxNodeAnalysisContext context,
-            PropertyDeclarationSyntax propertyDeclaration,
-            IPropertySymbol property)
-        {
-            if (!CommandParameterSymbol.IsParameterProperty(property))
-                return;
-
-            if (IsScalar(property.Type))
-                return;
-
-            var otherProperties = property
-                .ContainingType
-                .GetMembers()
-                .OfType<IPropertySymbol>()
-                .Where(m => !m.Equals(property, SymbolEqualityComparer.Default))
-                .ToArray();
-
-            foreach (var otherProperty in otherProperties)
             {
-                if (!CommandParameterSymbol.IsParameterProperty(otherProperty))
+                context.ReportDiagnostic(
-                    continue;
+                    CreateDiagnostic(
-
+                        propertyDeclaration.Identifier.GetLocation(),
-                if (!IsScalar(otherProperty.Type))
+                        otherProperty.Name
-                {
+                    )
-                    context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+                );
-                }
             }
         }
-
-        public override void Initialize(AnalysisContext context)
-        {
-            base.Initialize(context);
-            context.HandlePropertyDeclaration(Analyze);
-        }
     }
-}
+
+    public override void Initialize(AnalysisContext context)
+    {
+        base.Initialize(context);
+        context.HandlePropertyDeclaration(Analyze);
+    }
+}

CliFx.Analyzers/ParameterMustHaveUniqueNameAnalyzer.cs

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

CliFx.Analyzers/ParameterMustHaveUniqueOrderAnalyzer.cs

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

CliFx.Analyzers/ParameterMustHaveValidConverterAnalyzer.cs

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

CliFx.Analyzers/ParameterMustHaveValidValidatorsAnalyzer.cs

@@ -5,48 +5,54 @@ using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 
-namespace CliFx.Analyzers
+namespace CliFx.Analyzers;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public class ParameterMustHaveValidValidatorsAnalyzer()
+    : AnalyzerBase(
+        $"Parameter validators must derive from `{SymbolNames.CliFxBindingValidatorClass}`",
+        $"Each validator specified for this parameter must derive from a compatible `{SymbolNames.CliFxBindingValidatorClass}`."
+    )
 {
-    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    private void Analyze(
-    public class ParameterMustHaveValidValidatorsAnalyzer : AnalyzerBase
+        SyntaxNodeAnalysisContext context,
+        PropertyDeclarationSyntax propertyDeclaration,
+        IPropertySymbol property
+    )
     {
-        public ParameterMustHaveValidValidatorsAnalyzer()
+        var parameter = CommandParameterSymbol.TryResolve(property);
-            : base(
+        if (parameter is null)
-                $"Parameter validators must derive from `{SymbolNames.CliFxBindingValidatorClass}`",
+            return;
-                $"All validators specified for this parameter must derive from `{SymbolNames.CliFxBindingValidatorClass}`.")
-        {
-        }
 
-        private void Analyze(
+        foreach (var validatorType in parameter.ValidatorTypes)
-            SyntaxNodeAnalysisContext context,
-            PropertyDeclarationSyntax propertyDeclaration,
-            IPropertySymbol property)
         {
-            var parameter = CommandParameterSymbol.TryResolve(property);
+            var validatorValueType = validatorType
-            if (parameter is null)
+                .GetBaseTypes()
-                return;
+                .FirstOrDefault(t =>
+                    t.ConstructedFrom.DisplayNameMatches(SymbolNames.CliFxBindingValidatorClass)
+                )
+                ?.TypeArguments.FirstOrDefault();
 
-            foreach (var validatorType in parameter.ValidatorTypes)
+            // 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)
             {
-                // We check against an internal interface because checking against a generic class is a pain
+                context.ReportDiagnostic(
-                var validatorImplementsInterface = validatorType
+                    CreateDiagnostic(propertyDeclaration.Identifier.GetLocation())
-                    .AllInterfaces
+                );
-                    .Any(s => s.DisplayNameMatches(SymbolNames.CliFxBindingValidatorInterface));
 
-                if (!validatorImplementsInterface)
+                // No need to report multiple identical diagnostics on the same node
-                {
+                break;
-                    context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
-
-                    // No need to report multiple identical diagnostics on the same node
-                    break;
-                }
             }
         }
-
-        public override void Initialize(AnalysisContext context)
-        {
-            base.Initialize(context);
-            context.HandlePropertyDeclaration(Analyze);
-        }
     }
-}
+
+    public override void Initialize(AnalysisContext context)
+    {
+        base.Initialize(context);
+        context.HandlePropertyDeclaration(Analyze);
+    }
+}

CliFx.Analyzers/SystemConsoleShouldBeAvoidedAnalyzer.cs

@@ -6,72 +6,69 @@ using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 
-namespace CliFx.Analyzers
+namespace CliFx.Analyzers;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public class SystemConsoleShouldBeAvoidedAnalyzer()
+    : AnalyzerBase(
+        $"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
+    )
 {
-    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    private MemberAccessExpressionSyntax? TryGetSystemConsoleMemberAccess(
-    public class SystemConsoleShouldBeAvoidedAnalyzer : AnalyzerBase
+        SyntaxNodeAnalysisContext context,
+        SyntaxNode node
+    )
     {
-        public SystemConsoleShouldBeAvoidedAnalyzer()
+        var currentNode = node;
-            : 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(
+        while (currentNode is MemberAccessExpressionSyntax memberAccess)
-            SyntaxNodeAnalysisContext context,
-            SyntaxNode node)
         {
-            var currentNode = node;
+            var member = context.SemanticModel.GetSymbolInfo(memberAccess).Symbol;
 
-            while (currentNode is MemberAccessExpressionSyntax memberAccess)
+            if (member?.ContainingType?.DisplayNameMatches("System.Console") == true)
             {
-                var symbol = context.SemanticModel.GetSymbolInfo(memberAccess).Symbol;
+                return memberAccess;
-
-                if (symbol is not null && symbol.ContainingType.DisplayNameMatches("System.Console"))
-                {
-                    return memberAccess;
-                }
-
-                // Get inner expression, which may be another member access expression.
-                // Example: System.Console.Error
-                //          ~~~~~~~~~~~~~~          <- inner member access expression
-                //          --------------------    <- outer member access expression
-                currentNode = memberAccess.Expression;
             }
 
-            return null;
+            // 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;
         }
 
-        private void Analyze(SyntaxNodeAnalysisContext context)
+        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)
         {
-            // Try to get a member access on System.Console in the current expression,
+            context.ReportDiagnostic(CreateDiagnostic(systemConsoleMemberAccess.GetLocation()));
-            // 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);
         }
     }
-}
+
+    public override void Initialize(AnalysisContext context)
+    {
+        base.Initialize(context);
+        context.RegisterSyntaxNodeAction(Analyze, SyntaxKind.SimpleMemberAccessExpression);
+    }
+}

CliFx.Analyzers/Utils/Extensions/RoslynExtensions.cs

@@ -1,21 +1,66 @@
 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
+namespace CliFx.Analyzers.Utils.Extensions;
-{
-    internal static class RoslynExtensions
-    {
-        public static bool DisplayNameMatches(this ISymbol symbol, string name) =>
-            string.Equals(symbol.ToDisplayString(), name, StringComparison.Ordinal);
 
-        public static void HandleClassDeclaration(
+internal static class RoslynExtensions
-            this AnalysisContext analysisContext,
+{
-            Action<SyntaxNodeAnalysisContext, ClassDeclarationSyntax, ITypeSymbol> handler)
+    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)
         {
-            analysisContext.RegisterSyntaxNodeAction(ctx =>
+            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];
+
+    // Detect if the property is required through roundabout means so as to not have to take dependency
+    // on higher versions of the C# compiler.
+    public static bool IsRequired(this IPropertySymbol property) =>
+        property
+            // Can't rely on the RequiredMemberAttribute because it's generated by the compiler, not added by the user,
+            // so we have to check for the presence of the `required` modifier in the syntax tree instead.
+            .DeclaringSyntaxReferences.Select(r => r.GetSyntax())
+            .OfType<PropertyDeclarationSyntax>()
+            .SelectMany(p => p.Modifiers)
+            .Any(m => m.IsKind((SyntaxKind)8447));
+
+    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;
@@ -24,15 +69,19 @@ namespace CliFx.Analyzers.Utils.Extensions
                 if (type is null)
                     return;
 
-                handler(ctx, classDeclaration, type);
+                analyze(ctx, classDeclaration, type);
-            }, SyntaxKind.ClassDeclaration);
+            },
-        }
+            SyntaxKind.ClassDeclaration
+        );
+    }
 
-        public static void HandlePropertyDeclaration(
+    public static void HandlePropertyDeclaration(
-            this AnalysisContext analysisContext,
+        this AnalysisContext analysisContext,
-            Action<SyntaxNodeAnalysisContext, PropertyDeclarationSyntax, IPropertySymbol> handler)
+        Action<SyntaxNodeAnalysisContext, PropertyDeclarationSyntax, IPropertySymbol> analyze
-        {
+    )
-            analysisContext.RegisterSyntaxNodeAction(ctx =>
+    {
+        analysisContext.RegisterSyntaxNodeAction(
+            ctx =>
             {
                 if (ctx.Node is not PropertyDeclarationSyntax propertyDeclaration)
                     return;
@@ -41,8 +90,9 @@ namespace CliFx.Analyzers.Utils.Extensions
                 if (property is null)
                     return;
 
-                handler(ctx, propertyDeclaration, property);
+                analyze(ctx, propertyDeclaration, property);
-            }, SyntaxKind.PropertyDeclaration);
+            },
-        }
+            SyntaxKind.PropertyDeclaration
+        );
     }
-}
+}

CliFx.Analyzers/Utils/Extensions/StringExtensions.cs

@@ -1,18 +1,18 @@
 using System;
 
-namespace CliFx.Analyzers.Utils.Extensions
+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;
+internal static class StringExtensions
-        }
+{
+    public static string TrimEnd(
+        this string str,
+        string sub,
+        StringComparison comparison = StringComparison.Ordinal
+    )
+    {
+        while (str.EndsWith(sub, comparison))
+            str = str[..^sub.Length];
+
+        return str;
     }
-}
+}

CliFx.Benchmarks/Benchmarks.CliFx.cs

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

CliFx.Benchmarks/Benchmarks.Clipr.cs

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

CliFx.Benchmarks/Benchmarks.Cocona.cs

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

CliFx.Benchmarks/Benchmarks.CommandLineParser.cs

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

CliFx.Benchmarks/Benchmarks.McMaster.cs

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

CliFx.Benchmarks/Benchmarks.PowerArgs.cs

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

CliFx.Benchmarks/Benchmarks.SystemCommandLine.cs

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

CliFx.Benchmarks/Benchmarks.cs

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

CliFx.Benchmarks/CliFx.Benchmarks.csproj

@@ -2,17 +2,19 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net5.0</TargetFramework>
+    <TargetFramework>net9.0</TargetFramework>
+    <NuGetAudit>false</NuGetAudit>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="BenchmarkDotNet" Version="0.12.0" />
+    <PackageReference Include="BenchmarkDotNet" Version="0.14.0" />
     <PackageReference Include="clipr" Version="1.6.1" />
-    <PackageReference Include="Cocona" Version="1.5.0" />
+    <PackageReference Include="Cocona" Version="2.2.0" />
-    <PackageReference Include="CommandLineParser" Version="2.8.0" />
+    <PackageReference Include="CommandLineParser" Version="2.9.1" />
-    <PackageReference Include="McMaster.Extensions.CommandLineUtils" Version="3.1.0" />
+    <PackageReference Include="CSharpier.MsBuild" Version="0.30.6" PrivateAssets="all" />
-    <PackageReference Include="PowerArgs" Version="3.6.0" />
+    <PackageReference Include="McMaster.Extensions.CommandLineUtils" Version="4.1.1" />
-    <PackageReference Include="System.CommandLine" Version="2.0.0-beta1.20574.7" />
+    <PackageReference Include="PowerArgs" Version="4.0.3" />
+    <PackageReference Include="System.CommandLine" Version="2.0.0-beta4.22272.1" />
   </ItemGroup>
 
   <ItemGroup>

CliFx.Demo/CliFx.Demo.csproj

@@ -2,17 +2,18 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net5.0</TargetFramework>
+    <TargetFramework>net9.0</TargetFramework>
+    <ApplicationIcon>../favicon.ico</ApplicationIcon>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="5.0.1" />
+    <PackageReference Include="CSharpier.MsBuild" Version="0.30.6" PrivateAssets="all" />
-    <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="9.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>

CliFx.Demo/Commands/BookAddCommand.cs

@@ -6,65 +6,50 @@ using CliFx.Demo.Utils;
 using CliFx.Exceptions;
 using CliFx.Infrastructure;
 
-namespace CliFx.Demo.Commands
+namespace CliFx.Demo.Commands;
+
+[Command("book add", Description = "Adds a book to the library.")]
+public class BookAddCommand(LibraryProvider libraryProvider) : ICommand
 {
-    [Command("book add", Description = "Add a book to the library.")]
+    [CommandParameter(0, Name = "title", Description = "Book title.")]
-    public partial class BookAddCommand : ICommand
+    public required string Title { get; init; }
-    {
-        private readonly LibraryProvider _libraryProvider;
 
-        [CommandParameter(0, Name = "title", Description = "Book title.")]
+    [CommandOption("author", 'a', Description = "Book author.")]
-        public string Title { get; init; } = "";
+    public required string Author { get; init; }
 
-        [CommandOption("author", 'a', IsRequired = true, Description = "Book author.")]
+    [CommandOption("published", 'p', Description = "Book publish date.")]
-        public string Author { get; init; } = "";
+    public DateTimeOffset Published { get; init; } =
-
+        new(
-        [CommandOption("published", 'p', Description = "Book publish date.")]
+            Random.Shared.Next(1800, 2020),
-        public DateTimeOffset Published { get; init; } = CreateRandomDate();
+            Random.Shared.Next(1, 12),
-
+            Random.Shared.Next(1, 28),
-        [CommandOption("isbn", 'n', Description = "Book ISBN.")]
+            Random.Shared.Next(1, 23),
-        public Isbn Isbn { get; init; } = CreateRandomIsbn();
+            Random.Shared.Next(1, 59),
-
+            Random.Shared.Next(1, 59),
-        public BookAddCommand(LibraryProvider libraryProvider)
-        {
-            _libraryProvider = libraryProvider;
-        }
-
-        public ValueTask ExecuteAsync(IConsole console)
-        {
-            if (_libraryProvider.TryGetBook(Title) is not null)
-                throw new CommandException("Book already exists.", 10);
-
-            var book = new Book(Title, Author, Published, Isbn);
-            _libraryProvider.AddBook(book);
-
-            console.Output.WriteLine("Book added.");
-            console.Output.WriteBook(book);
-
-            return default;
-        }
-    }
-
-    public partial class BookAddCommand
-    {
-        private static readonly Random Random = new();
-
-        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
         );
 
-        private static Isbn CreateRandomIsbn() => new(
+    [CommandOption("isbn", 'n', Description = "Book ISBN.")]
-            Random.Next(0, 999),
+    public Isbn Isbn { get; init; } =
-            Random.Next(0, 99),
+        new(
-            Random.Next(0, 99999),
+            Random.Shared.Next(0, 999),
-            Random.Next(0, 99),
+            Random.Shared.Next(0, 99),
-            Random.Next(0, 9)
+            Random.Shared.Next(0, 99999),
+            Random.Shared.Next(0, 99),
+            Random.Shared.Next(0, 9)
         );
+
+    public ValueTask ExecuteAsync(IConsole console)
+    {
+        if (libraryProvider.TryGetBook(Title) is not null)
+            throw new CommandException($"Book '{Title}' already exists.", 10);
+
+        var book = new Book(Title, Author, Published, Isbn);
+        libraryProvider.AddBook(book);
+
+        console.WriteLine($"Book '{Title}' added.");
+        console.WriteBook(book);
+
+        return default;
     }
-}
+}

CliFx.Demo/Commands/BookCommand.cs

@@ -5,31 +5,23 @@ using CliFx.Demo.Utils;
 using CliFx.Exceptions;
 using CliFx.Infrastructure;
 
-namespace CliFx.Demo.Commands
+namespace CliFx.Demo.Commands;
+
+[Command("book", Description = "Retrieves a book from the library.")]
+public class BookCommand(LibraryProvider libraryProvider) : ICommand
 {
-    [Command("book", Description = "Retrieve a book from the library.")]
+    [CommandParameter(0, Name = "title", Description = "Title of the book to retrieve.")]
-    public class BookCommand : ICommand
+    public required string Title { get; init; }
+
+    public ValueTask ExecuteAsync(IConsole console)
     {
-        private readonly LibraryProvider _libraryProvider;
+        var book = libraryProvider.TryGetBook(Title);
 
-        [CommandParameter(0, Name = "title", Description = "Title of the book to retrieve.")]
+        if (book is null)
-        public string Title { get; init; } = "";
+            throw new CommandException($"Book '{Title}' not found.", 10);
 
-        public BookCommand(LibraryProvider libraryProvider)
+        console.WriteBook(book);
-        {
-            _libraryProvider = libraryProvider;
-        }
 
-        public ValueTask ExecuteAsync(IConsole console)
+        return default;
-        {
-            var book = _libraryProvider.TryGetBook(Title);
-
-            if (book is null)
-                throw new CommandException("Book not found.", 10);
-
-            console.Output.WriteBook(book);
-
-            return default;
-        }
     }
-}
+}

CliFx.Demo/Commands/BookListCommand.cs

@@ -4,34 +4,26 @@ using CliFx.Demo.Domain;
 using CliFx.Demo.Utils;
 using CliFx.Infrastructure;
 
-namespace CliFx.Demo.Commands
+namespace CliFx.Demo.Commands;
+
+[Command("book list", Description = "Lists all books in the library.")]
+public class BookListCommand(LibraryProvider libraryProvider) : ICommand
 {
-    [Command("book list", Description = "List all books in the library.")]
+    public ValueTask ExecuteAsync(IConsole console)
-    public class BookListCommand : ICommand
     {
-        private readonly LibraryProvider _libraryProvider;
+        var library = libraryProvider.GetLibrary();
 
-        public BookListCommand(LibraryProvider libraryProvider)
+        for (var i = 0; i < library.Books.Count; i++)
         {
-            _libraryProvider = libraryProvider;
+            // Add margin
+            if (i != 0)
+                console.WriteLine();
+
+            // Render book
+            var book = library.Books[i];
+            console.WriteBook(book);
         }
 
-        public ValueTask ExecuteAsync(IConsole console)
+        return default;
-        {
-            var library = _libraryProvider.GetLibrary();
-
-            for (var i = 0; i < library.Books.Count; i++)
-            {
-                // Add margin
-                if (i != 0)
-                    console.Output.WriteLine();
-
-                // Render book
-                var book = library.Books[i];
-                console.Output.WriteBook(book);
-            }
-
-            return default;
-        }
     }
-}
+}

CliFx.Demo/Commands/BookRemoveCommand.cs

@@ -4,33 +4,25 @@ using CliFx.Demo.Domain;
 using CliFx.Exceptions;
 using CliFx.Infrastructure;
 
-namespace CliFx.Demo.Commands
+namespace CliFx.Demo.Commands;
+
+[Command("book remove", Description = "Removes a book from the library.")]
+public class BookRemoveCommand(LibraryProvider libraryProvider) : ICommand
 {
-    [Command("book remove", Description = "Remove a book from the library.")]
+    [CommandParameter(0, Name = "title", Description = "Title of the book to remove.")]
-    public class BookRemoveCommand : ICommand
+    public required string Title { get; init; }
+
+    public ValueTask ExecuteAsync(IConsole console)
     {
-        private readonly LibraryProvider _libraryProvider;
+        var book = libraryProvider.TryGetBook(Title);
 
-        [CommandParameter(0, Name = "title", Description = "Title of the book to remove.")]
+        if (book is null)
-        public string Title { get; init; } = "";
+            throw new CommandException($"Book '{Title}' not found.", 10);
 
-        public BookRemoveCommand(LibraryProvider libraryProvider)
+        libraryProvider.RemoveBook(book);
-        {
-            _libraryProvider = libraryProvider;
-        }
 
-        public ValueTask ExecuteAsync(IConsole console)
+        console.WriteLine($"Book '{Title}' removed.");
-        {
-            var book = _libraryProvider.TryGetBook(Title);
 
-            if (book is null)
+        return default;
-                throw new CommandException("Book not found.", 10);
-
-            _libraryProvider.RemoveBook(book);
-
-            console.Output.WriteLine($"Book {Title} removed.");
-
-            return default;
-        }
     }
-}
+}

CliFx.Demo/Domain/Book.cs

@@ -1,23 +1,5 @@
 using System;
 
-namespace CliFx.Demo.Domain
+namespace CliFx.Demo.Domain;
-{
-    public class Book
-    {
-        public string Title { get; }
 
-        public string Author { get; }
+public record Book(string Title, string Author, DateTimeOffset Published, Isbn Isbn);
-
-        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;
-        }
-    }
-}

CliFx.Demo/Domain/Isbn.cs

@@ -1,45 +1,31 @@
 using System;
 
-namespace CliFx.Demo.Domain
+namespace CliFx.Demo.Domain;
+
+public partial record Isbn(
+    int EanPrefix,
+    int RegistrationGroup,
+    int Registrant,
+    int Publication,
+    int CheckDigit
+)
 {
-    public partial class Isbn
+    public override string ToString() =>
+        $"{EanPrefix:000}-{RegistrationGroup:00}-{Registrant:00000}-{Publication:00}-{CheckDigit:0}";
+}
+
+public partial record Isbn
+{
+    public static Isbn Parse(string value, IFormatProvider formatProvider)
     {
-        public int EanPrefix { get; }
+        var components = value.Split('-', 5, StringSplitOptions.RemoveEmptyEntries);
 
-        public int RegistrationGroup { get; }
+        return new Isbn(
-
+            int.Parse(components[0], formatProvider),
-        public int Registrant { get; }
+            int.Parse(components[1], formatProvider),
-
+            int.Parse(components[2], formatProvider),
-        public int Publication { get; }
+            int.Parse(components[3], formatProvider),
-
+            int.Parse(components[4], formatProvider)
-        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)
-            );
-        }
-    }
-}

CliFx.Demo/Domain/Library.cs

@@ -2,35 +2,27 @@
 using System.Collections.Generic;
 using System.Linq;
 
-namespace CliFx.Demo.Domain
+namespace CliFx.Demo.Domain;
+
+public partial record Library(IReadOnlyList<Book> Books)
 {
-    public partial class Library
+    public Library WithBook(Book book)
     {
-        public IReadOnlyList<Book> Books { get; }
+        var books = Books.ToList();
+        books.Add(book);
 
-        public Library(IReadOnlyList<Book> books)
+        return new Library(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 Library WithoutBook(Book book)
     {
-        public static Library Empty { get; } = new(Array.Empty<Book>());
+        var books = Books.Where(b => b != book).ToArray();
+
+        return new Library(books);
     }
-}
+}
+
+public partial record Library
+{
+    public static Library Empty { get; } = new(Array.Empty<Book>());
+}

CliFx.Demo/Domain/LibraryProvider.cs

@@ -1,41 +1,42 @@
 using System.IO;
 using System.Linq;
-using Newtonsoft.Json;
+using System.Text.Json;
 
-namespace CliFx.Demo.Domain
+namespace CliFx.Demo.Domain;
+
+public class LibraryProvider
 {
-    public class LibraryProvider
+    private static string StorageFilePath { get; } =
+        Path.Combine(Directory.GetCurrentDirectory(), "Library.json");
+
+    private void StoreLibrary(Library library)
     {
-        private static string StorageFilePath { get; } = Path.Combine(Directory.GetCurrentDirectory(), "Library.json");
+        var data = JsonSerializer.Serialize(library);
-
+        File.WriteAllText(StorageFilePath, data);
-        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);
-        }
-
-        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);
-        }
     }
-}
+
+    public Library GetLibrary()
+    {
+        if (!File.Exists(StorageFilePath))
+            return Library.Empty;
+
+        var data = File.ReadAllText(StorageFilePath);
+
+        return JsonSerializer.Deserialize<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);
+    }
+}

CliFx.Demo/Program.cs

@@ -1,36 +1,21 @@
-using System;
+using CliFx;
-using System.Threading.Tasks;
-using CliFx.Demo.Commands;
 using CliFx.Demo.Domain;
 using Microsoft.Extensions.DependencyInjection;
 
-namespace CliFx.Demo
+return await new CliApplicationBuilder()
-{
+    .SetDescription("Demo application showcasing CliFx features.")
-    public static class Program
+    .AddCommandsFromThisAssembly()
+    .UseTypeActivator(commandTypes =>
     {
-        private static IServiceProvider GetServiceProvider()
+        // We use Microsoft.Extensions.DependencyInjection for injecting dependencies in commands
-        {
+        var services = new ServiceCollection();
-            // We use Microsoft.Extensions.DependencyInjection for injecting dependencies in commands
+        services.AddSingleton<LibraryProvider>();
-            var services = new ServiceCollection();
 
-            // Register services
+        // Register all commands as transient services
-            services.AddSingleton<LibraryProvider>();
+        foreach (var commandType in commandTypes)
+            services.AddTransient(commandType);
 
-            // Register commands
+        return services.BuildServiceProvider();
-            services.AddTransient<BookCommand>();
+    })
-            services.AddTransient<BookAddCommand>();
+    .Build()
-            services.AddTransient<BookRemoveCommand>();
+    .RunAsync();
-            services.AddTransient<BookListCommand>();
-
-            return services.BuildServiceProvider();
-        }
-
-        public static async Task<int> Main() =>
-            await new CliApplicationBuilder()
-                .SetDescription("Demo application showcasing CliFx features.")
-                .AddCommandsFromThisAssembly()
-                .UseTypeActivator(GetServiceProvider().GetRequiredService)
-                .Build()
-                .RunAsync();
-    }
-}

CliFx.Demo/Readme.md

@@ -1,5 +1,5 @@
 # CliFx Demo Project
 
-Sample command line interface for managing a library of books.
+Sample command-line interface for managing a library of books.
 
-This demo project showcases basic CliFx functionality such as command routing, argument parsing, autogenerated help text.
+This demo project showcases basic CliFx functionality such as command routing, argument parsing, and autogenerated help text.

CliFx.Demo/Utils/ConsoleExtensions.cs

@@ -2,36 +2,38 @@
 using CliFx.Demo.Domain;
 using CliFx.Infrastructure;
 
-namespace CliFx.Demo.Utils
+namespace CliFx.Demo.Utils;
+
+internal static class ConsoleExtensions
 {
-    internal static class ConsoleExtensions
+    public static void WriteBook(this ConsoleWriter writer, Book book)
     {
-        public static void WriteBook(this ConsoleWriter writer, Book book)
+        // Title
-        {
+        using (writer.Console.WithForegroundColor(ConsoleColor.White))
-            // Title
+            writer.WriteLine(book.Title);
-            using (writer.Console.WithForegroundColor(ConsoleColor.White))
-                writer.WriteLine(book.Title);
 
-            // Author
+        // Author
-            writer.Write("  ");
+        writer.Write("  ");
-            writer.Write("Author: ");
+        writer.Write("Author: ");
 
-            using (writer.Console.WithForegroundColor(ConsoleColor.White))
+        using (writer.Console.WithForegroundColor(ConsoleColor.White))
-                writer.WriteLine(book.Author);
+            writer.WriteLine(book.Author);
 
-            // Published
+        // Published
-            writer.Write("  ");
+        writer.Write("  ");
-            writer.Write("Published: ");
+        writer.Write("Published: ");
 
-            using (writer.Console.WithForegroundColor(ConsoleColor.White))
+        using (writer.Console.WithForegroundColor(ConsoleColor.White))
-                writer.WriteLine($"{book.Published:d}");
+            writer.WriteLine($"{book.Published:d}");
 
-            // ISBN
+        // ISBN
-            writer.Write("  ");
+        writer.Write("  ");
-            writer.Write("ISBN: ");
+        writer.Write("ISBN: ");
 
-            using (writer.Console.WithForegroundColor(ConsoleColor.White))
+        using (writer.Console.WithForegroundColor(ConsoleColor.White))
-                writer.WriteLine(book.Isbn);
+            writer.WriteLine(book.Isbn);
-        }
     }
-}
+
+    public static void WriteBook(this IConsole console, Book book) =>
+        console.Output.WriteBook(book);
+}

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

@@ -2,12 +2,17 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net5.0</TargetFramework>
+    <TargetFramework>net9.0</TargetFramework>
+    <ApplicationIcon>../favicon.ico</ApplicationIcon>
   </PropertyGroup>
 
+  <ItemGroup>
+    <PackageReference Include="CSharpier.MsBuild" Version="0.30.6" PrivateAssets="all" />
+  </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>

CliFx.Tests.Dummy/Commands/CancellationTestCommand.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Threading.Tasks;
+using CliFx.Attributes;
+using CliFx.Infrastructure;
+
+namespace CliFx.Tests.Dummy.Commands;
+
+[Command("cancel-test")]
+public class CancellationTestCommand : ICommand
+{
+    public async ValueTask ExecuteAsync(IConsole console)
+    {
+        try
+        {
+            console.WriteLine("Started.");
+
+            await Task.Delay(TimeSpan.FromSeconds(3), console.RegisterCancellationHandler());
+
+            console.WriteLine("Completed.");
+        }
+        catch (OperationCanceledException)
+        {
+            console.WriteLine("Cancelled.");
+            throw;
+        }
+    }
+}

CliFx.Tests.Dummy/Commands/ConsoleTestCommand.cs

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

CliFx.Tests.Dummy/Commands/EnvironmentTestCommand.cs

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

CliFx.Tests.Dummy/Program.cs

@@ -1,24 +1,29 @@
-using System.Reflection;
+using System;
+using System.IO;
+using System.Reflection;
+using System.Runtime.InteropServices;
 using System.Threading.Tasks;
 
-namespace CliFx.Tests.Dummy
+namespace CliFx.Tests.Dummy;
+
+// This dummy application is used in tests for scenarios that require an external process to properly verify
+public static class Program
 {
-    // This dummy application is used in tests for scenarios
+    // Path to the apphost
-    // that require an external process to properly verify.
+    public static string FilePath { get; } =
+        Path.ChangeExtension(
+            Assembly.GetExecutingAssembly().Location,
+            RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "exe" : null
+        );
 
-    public static partial class Program
+    public static async Task Main()
     {
-        public static Assembly Assembly { get; } = typeof(Program).Assembly;
+        // Make sure color codes are not produced because we rely on the output in tests
+        Environment.SetEnvironmentVariable(
+            "DOTNET_SYSTEM_CONSOLE_ALLOW_ANSI_COLOR_REDIRECTION",
+            "false"
+        );
 
-        public static string Location { get; } = Assembly.Location;
+        await new CliApplicationBuilder().AddCommandsFromThisAssembly().Build().RunAsync();
     }
-
+}
-    public static partial class Program
-    {
-        public static async Task Main() =>
-            await new CliApplicationBuilder()
-                .AddCommandsFromThisAssembly()
-                .Build()
-                .RunAsync();
-    }
-}

CliFx.Tests/ApplicationSpecs.cs

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

CliFx.Tests/CancellationSpecs.cs

@@ -1,67 +1,107 @@
 using System;
 using System.Collections.Generic;
+using System.Text;
+using System.Threading;
 using System.Threading.Tasks;
 using CliFx.Tests.Utils;
+using CliFx.Tests.Utils.Extensions;
+using CliWrap;
 using FluentAssertions;
 using Xunit;
 using Xunit.Abstractions;
 
-namespace CliFx.Tests
+namespace CliFx.Tests;
+
+public class CancellationSpecs(ITestOutputHelper testOutput) : SpecsBase(testOutput)
 {
-    public class CancellationSpecs : SpecsBase
+    [Fact(Timeout = 15000)]
+    public async Task I_can_configure_the_command_to_listen_to_the_interrupt_signal()
     {
-        public CancellationSpecs(ITestOutputHelper testOutput)
+        // Arrange
-            : base(testOutput)
+        using var cts = new CancellationTokenSource();
+
+        // We need to send the cancellation request right after the process has registered
+        // a handler for the interrupt signal, otherwise the default handler will trigger
+        // and just kill the process.
+        void HandleStdOut(string line)
         {
+            if (string.Equals(line, "Started.", StringComparison.OrdinalIgnoreCase))
+                cts.CancelAfter(TimeSpan.FromSeconds(0.2));
         }
 
-        [Fact]
+        var stdOutBuffer = new StringBuilder();
-        public async Task Command_can_register_to_receive_a_cancellation_signal_from_the_console()
+
-        {
+        var pipeTarget = PipeTarget.Merge(
-            // Arrange
+            PipeTarget.ToDelegate(HandleStdOut),
-            var commandType = DynamicCommandBuilder.Compile(
+            PipeTarget.ToStringBuilder(stdOutBuffer)
-                // language=cs
+        );
-                @"
+
-[Command]
+        var command = Cli.Wrap(Dummy.Program.FilePath).WithArguments("cancel-test") | pipeTarget;
-public class Command : ICommand
+
-{
+        // Act & assert
-    public async ValueTask ExecuteAsync(IConsole console)
+        await Assert.ThrowsAnyAsync<OperationCanceledException>(
+            async () =>
+                await command.ExecuteAsync(
+                    // Forceful cancellation (not required because we have a timeout)
+                    CancellationToken.None,
+                    // Graceful cancellation
+                    cts.Token
+                )
+        );
+
+        stdOutBuffer.ToString().Trim().Should().ConsistOfLines("Started.", "Cancelled.");
+    }
+
+    [Fact]
+    public async Task I_can_configure_the_command_to_listen_to_the_interrupt_signal_when_running_in_isolation()
     {
-        try
+        // Arrange
-        {
+        var commandType = DynamicCommandBuilder.Compile(
-            await Task.Delay(
+            // lang=csharp
-                TimeSpan.FromSeconds(3),
+            """
-                console.RegisterCancellationHandler()
+            [Command]
-            );
+            public class Command : ICommand
+            {
+                public async ValueTask ExecuteAsync(IConsole console)
+                {
+                    try
+                    {
+                        console.WriteLine("Started.");
 
-            console.Output.WriteLine(""Completed successfully"");
+                        await Task.Delay(
-        }
+                            TimeSpan.FromSeconds(3),
-        catch (OperationCanceledException)
+                            console.RegisterCancellationHandler()
-        {
+                        );
-            console.Output.WriteLine(""Cancelled"");
+
-            throw;
+                        console.WriteLine("Completed.");
-        }
+                    }
+                    catch (OperationCanceledException)
+                    {
+                        console.WriteLine("Cancelled.");
+                        throw;
+                    }
+                }
+            }
+            """
+        );
+
+        var application = new CliApplicationBuilder()
+            .AddCommand(commandType)
+            .UseConsole(FakeConsole)
+            .Build();
+
+        FakeConsole.RequestCancellation(TimeSpan.FromSeconds(0.2));
+
+        // Act
+        var exitCode = await application.RunAsync(
+            Array.Empty<string>(),
+            new Dictionary<string, string>()
+        );
+
+        // Assert
+        exitCode.Should().NotBe(0);
+
+        var stdOut = FakeConsole.ReadOutputString();
+        stdOut.Trim().Should().ConsistOfLines("Started.", "Cancelled.");
     }
-}");
+}
-
-            var application = new CliApplicationBuilder()
-                .AddCommand(commandType)
-                .UseConsole(FakeConsole)
-                .Build();
-
-            // Act
-            FakeConsole.RequestCancellation(TimeSpan.FromSeconds(0.2));
-
-            var exitCode = await application.RunAsync(
-                Array.Empty<string>(),
-                new Dictionary<string, string>()
-            );
-
-            var stdOut = FakeConsole.ReadOutputString();
-
-            // Assert
-            exitCode.Should().NotBe(0);
-            stdOut.Trim().Should().Be("Cancelled");
-        }
-    }
-}

CliFx.Tests/CliFx.Tests.csproj

@@ -1,11 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net5.0</TargetFramework>
+    <TargetFramework>net9.0</TargetFramework>
-    <IsPackable>false</IsPackable>
-    <IsTestProject>true</IsTestProject>
-    <CollectCoverage>true</CollectCoverage>
-    <CoverletOutputFormat>opencover</CoverletOutputFormat>
   </PropertyGroup>
 
   <ItemGroup>
@@ -13,14 +9,18 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="CliWrap" Version="3.3.1" />
+    <PackageReference Include="Basic.Reference.Assemblies.Net80" Version="1.8.0" />
-    <PackageReference Include="FluentAssertions" Version="5.10.3" />
+    <PackageReference Include="CliWrap" Version="3.7.1" />
-    <PackageReference Include="GitHubActionsTestLogger" Version="1.2.0" />
+    <PackageReference Include="coverlet.collector" Version="6.0.4" PrivateAssets="all" />
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="3.4.0" />
+    <PackageReference Include="CSharpier.MsBuild" Version="0.30.6" PrivateAssets="all" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.9.1" />
+    <PackageReference Include="FluentAssertions" Version="8.0.1" />
-    <PackageReference Include="xunit" Version="2.4.1" />
+    <PackageReference Include="GitHubActionsTestLogger" Version="2.4.1" PrivateAssets="all" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3" PrivateAssets="all" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.11.0" />
-    <PackageReference Include="coverlet.msbuild" Version="3.0.3" PrivateAssets="all" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="9.0.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
+    <PackageReference Include="PolyShim" Version="1.14.0" PrivateAssets="all" />
+    <PackageReference Include="xunit" Version="2.9.3" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="3.0.1" PrivateAssets="all" />
   </ItemGroup>
 
   <ItemGroup>
@@ -28,12 +28,4 @@
     <ProjectReference Include="..\CliFx\CliFx.csproj" />
   </ItemGroup>
 
-  <ItemGroup>
-    <None Include="../CliFx.Tests.Dummy/bin/$(Configuration)/$(TargetFramework)/CliFx.Tests.Dummy.runtimeconfig.json">
-      <Link>CliFx.Tests.Dummy.runtimeconfig.json</Link>
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-      <Visible>false</Visible>
-    </None>
-  </ItemGroup>
-
 </Project>

CliFx.Tests/ConsoleSpecs.cs

@@ -1,139 +1,204 @@
 using System;
 using System.Collections.Generic;
+using System.IO;
+using System.Text;
 using System.Threading.Tasks;
+using CliFx.Infrastructure;
 using CliFx.Tests.Utils;
+using CliFx.Tests.Utils.Extensions;
 using CliWrap;
 using CliWrap.Buffered;
 using FluentAssertions;
 using Xunit;
 using Xunit.Abstractions;
 
-namespace CliFx.Tests
+namespace CliFx.Tests;
+
+public class ConsoleSpecs(ITestOutputHelper testOutput) : SpecsBase(testOutput)
 {
-    public class ConsoleSpecs : SpecsBase
+    [Fact(Timeout = 15000)]
+    public async Task I_can_run_the_application_with_the_default_console_implementation_to_interact_with_the_system_console()
     {
-        public ConsoleSpecs(ITestOutputHelper testOutput)
+        // Can't verify our own console output, so using an external process for this test
-            : base(testOutput)
-        {
-        }
 
-        [Fact]
+        // Arrange
-        public async Task Real_console_maps_directly_to_system_console()
+        var command =
-        {
+            "Hello world" | Cli.Wrap(Dummy.Program.FilePath).WithArguments("console-test");
-            // Can't verify our own console output, so using an
-            // external process for this test.
 
-            // Arrange
+        // Act
-            var command = "Hello world" | Cli.Wrap("dotnet")
+        var result = await command.ExecuteBufferedAsync();
-                .WithArguments(a => a
-                    .Add(Dummy.Program.Location)
-                    .Add("console-test"));
 
-            // Act
+        // Assert
-            var result = await command.ExecuteBufferedAsync();
+        result.StandardOutput.Trim().Should().Be("Hello world");
+        result.StandardError.Trim().Should().Be("Hello world");
+    }
 
-            // Assert
+    [Fact]
-            result.StandardOutput.Trim().Should().Be("Hello world");
+    public void I_can_run_the_application_on_a_system_with_a_custom_console_encoding_and_not_get_corrupted_output()
-            result.StandardError.Trim().Should().Be("Hello world");
-        }
-
-        [Fact]
-        public async Task Fake_console_does_not_leak_to_system_console()
-        {
-            // Arrange
-            var commandType = DynamicCommandBuilder.Compile(
-                // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{   
-    public ValueTask ExecuteAsync(IConsole console)
     {
-        console.ResetColor();
+        // Arrange
-        console.ForegroundColor = ConsoleColor.DarkMagenta;
+        using var buffer = new MemoryStream();
-        console.BackgroundColor = ConsoleColor.DarkMagenta;
+        using var consoleWriter = new ConsoleWriter(FakeConsole, buffer, Encoding.UTF8);
-        console.CursorLeft = 42;
-        console.CursorTop = 24;
 
-        console.Output.WriteLine(""Hello "");
+        // Act
-        console.Error.WriteLine(""world!"");
+        consoleWriter.Write("Hello world");
+        consoleWriter.Flush();
 
-        return default;
+        // Assert
+        var outputBytes = buffer.ToArray();
+        outputBytes.Should().NotContain(Encoding.UTF8.GetPreamble());
+
+        var output = consoleWriter.Encoding.GetString(outputBytes);
+        output.Should().Be("Hello world");
+    }
+
+    [Fact]
+    public async Task I_can_run_the_application_with_the_fake_console_implementation_to_isolate_console_interactions()
+    {
+        // Arrange
+        var commandType = DynamicCommandBuilder.Compile(
+            // lang=csharp
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.ResetColor();
+                    console.ForegroundColor = ConsoleColor.DarkMagenta;
+                    console.BackgroundColor = ConsoleColor.DarkMagenta;
+                    console.WindowWidth = 100;
+                    console.WindowHeight = 25;
+                    console.CursorLeft = 42;
+                    console.CursorTop = 24;
+
+                    console.Output.WriteLine("Hello ");
+                    console.Error.WriteLine("world!");
+
+                    return default;
+                }
+            }
+            """
+        );
+
+        var application = new CliApplicationBuilder()
+            .AddCommand(commandType)
+            .UseConsole(FakeConsole)
+            .Build();
+
+        // Act
+        var exitCode = await application.RunAsync(
+            Array.Empty<string>(),
+            new Dictionary<string, string>()
+        );
+
+        // Assert
+        exitCode.Should().Be(0);
+
+        Console.OpenStandardInput().Should().NotBeSameAs(FakeConsole.Input.BaseStream);
+        Console.OpenStandardOutput().Should().NotBeSameAs(FakeConsole.Output.BaseStream);
+        Console.OpenStandardError().Should().NotBeSameAs(FakeConsole.Error.BaseStream);
+
+        Console.ForegroundColor.Should().NotBe(ConsoleColor.DarkMagenta);
+        Console.BackgroundColor.Should().NotBe(ConsoleColor.DarkMagenta);
+
+        // This fails because tests don't spawn a console window
+        //Console.WindowWidth.Should().Be(100);
+        //Console.WindowHeight.Should().Be(25);
+        //Console.CursorLeft.Should().NotBe(42);
+        //Console.CursorTop.Should().NotBe(24);
+
+        FakeConsole.IsInputRedirected.Should().BeTrue();
+        FakeConsole.IsOutputRedirected.Should().BeTrue();
+        FakeConsole.IsErrorRedirected.Should().BeTrue();
+    }
+
+    [Fact]
+    public async Task I_can_run_the_application_with_the_fake_console_implementation_and_simulate_stream_interactions()
+    {
+        // Arrange
+        var commandType = DynamicCommandBuilder.Compile(
+            // lang=csharp
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    var input = console.Input.ReadToEnd();
+                    console.Output.WriteLine(input);
+                    console.Error.WriteLine(input);
+
+                    return default;
+                }
+            }
+            """
+        );
+
+        var application = new CliApplicationBuilder()
+            .AddCommand(commandType)
+            .UseConsole(FakeConsole)
+            .Build();
+
+        // Act
+        FakeConsole.WriteInput("Hello world");
+
+        var exitCode = await application.RunAsync(
+            Array.Empty<string>(),
+            new Dictionary<string, string>()
+        );
+
+        // Assert
+        exitCode.Should().Be(0);
+
+        var stdOut = FakeConsole.ReadOutputString();
+        stdOut.Trim().Should().Be("Hello world");
+
+        var stdErr = FakeConsole.ReadErrorString();
+        stdErr.Trim().Should().Be("Hello world");
+    }
+
+    [Fact]
+    public async Task I_can_run_the_application_with_the_fake_console_implementation_and_simulate_key_presses()
+    {
+        // Arrange
+        var commandType = DynamicCommandBuilder.Compile(
+            // lang=csharp
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.WriteLine(console.ReadKey().Key);
+                    console.WriteLine(console.ReadKey().Key);
+                    console.WriteLine(console.ReadKey().Key);
+
+                    return default;
+                }
+            }
+            """
+        );
+
+        var application = new CliApplicationBuilder()
+            .AddCommand(commandType)
+            .UseConsole(FakeConsole)
+            .Build();
+
+        // Act
+        FakeConsole.EnqueueKey(new ConsoleKeyInfo('0', ConsoleKey.D0, false, false, false));
+        FakeConsole.EnqueueKey(new ConsoleKeyInfo('a', ConsoleKey.A, false, false, false));
+        FakeConsole.EnqueueKey(new ConsoleKeyInfo('\0', ConsoleKey.Backspace, false, false, false));
+
+        var exitCode = await application.RunAsync(
+            Array.Empty<string>(),
+            new Dictionary<string, string>()
+        );
+
+        // Assert
+        exitCode.Should().Be(0);
+
+        var stdOut = FakeConsole.ReadOutputString();
+        stdOut.Trim().Should().ConsistOfLines("D0", "A", "Backspace");
     }
 }
-");
-
-            var application = new CliApplicationBuilder()
-                .AddCommand(commandType)
-                .UseConsole(FakeConsole)
-                .Build();
-
-            // Act
-            var exitCode = await application.RunAsync(
-                Array.Empty<string>(),
-                new Dictionary<string, string>()
-            );
-
-            // Assert
-            exitCode.Should().Be(0);
-
-            Console.OpenStandardInput().Should().NotBe(FakeConsole.Input.BaseStream);
-            Console.OpenStandardOutput().Should().NotBe(FakeConsole.Output.BaseStream);
-            Console.OpenStandardError().Should().NotBe(FakeConsole.Error.BaseStream);
-
-            Console.ForegroundColor.Should().NotBe(ConsoleColor.DarkMagenta);
-            Console.BackgroundColor.Should().NotBe(ConsoleColor.DarkMagenta);
-
-            // This fails because tests don't spawn a console window
-            //Console.CursorLeft.Should().NotBe(42);
-            //Console.CursorTop.Should().NotBe(24);
-
-            FakeConsole.IsInputRedirected.Should().BeTrue();
-            FakeConsole.IsOutputRedirected.Should().BeTrue();
-            FakeConsole.IsErrorRedirected.Should().BeTrue();
-        }
-
-        [Fact]
-        public async Task Fake_console_can_be_used_with_an_in_memory_backing_store()
-        {
-            // Arrange
-            var commandType = DynamicCommandBuilder.Compile(
-                // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{   
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        var input = console.Input.ReadToEnd();
-        console.Output.WriteLine(input);
-        console.Error.WriteLine(input);
-
-        return default;
-    }
-}
-");
-
-            var application = new CliApplicationBuilder()
-                .AddCommand(commandType)
-                .UseConsole(FakeConsole)
-                .Build();
-
-            // Act
-            FakeConsole.WriteInput("Hello world");
-
-            var exitCode = await application.RunAsync(
-                Array.Empty<string>(),
-                new Dictionary<string, string>()
-            );
-
-            var stdOut = FakeConsole.ReadOutputString();
-            var stdErr = FakeConsole.ReadErrorString();
-
-            // Assert
-            exitCode.Should().Be(0);
-            stdOut.Trim().Should().Be("Hello world");
-            stdErr.Trim().Should().Be("Hello world");
-        }
-    }
-}

CliFx.Tests/DirectivesSpecs.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using CliFx.Tests.Utils;
@@ -10,103 +9,83 @@ using FluentAssertions;
 using Xunit;
 using Xunit.Abstractions;
 
-namespace CliFx.Tests
+namespace CliFx.Tests;
+
+public class DirectivesSpecs(ITestOutputHelper testOutput) : SpecsBase(testOutput)
 {
-    public class DirectivesSpecs : SpecsBase
+    [Fact(Timeout = 15000)]
+    public async Task I_can_use_the_debug_directive_to_make_the_application_wait_for_the_debugger_to_attach()
     {
-        public DirectivesSpecs(ITestOutputHelper testOutput)
+        // Arrange
-            : base(testOutput)
+        using var cts = new CancellationTokenSource();
+
+        // We can't actually attach a debugger, but we can ensure that the process is waiting for one
+        void HandleStdOut(string line)
         {
+            // Kill the process once it writes the output we expect
+            if (line.Contains("Attach the debugger to", StringComparison.OrdinalIgnoreCase))
+                cts.Cancel();
         }
 
-        [Fact]
+        var command = Cli.Wrap(Dummy.Program.FilePath).WithArguments("[debug]") | HandleStdOut;
-        public async Task Debug_directive_can_be_specified_to_interrupt_execution_until_a_debugger_is_attached()
+
+        // Act & assert
+        try
         {
-            // Arrange
+            await command.ExecuteAsync(cts.Token);
-            var stdOutBuffer = new StringBuilder();
-
-            var command = Cli.Wrap("dotnet")
-                .WithArguments(a => a
-                    .Add(Dummy.Program.Location)
-                    .Add("[debug]")) | stdOutBuffer;
-
-            // Act
-            try
-            {
-                // This has a timeout just in case the execution hangs forever
-                using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
-
-                var task = command.ExecuteAsync(cts.Token);
-
-                // We can't attach a debugger programmatically, so the application
-                // will hang indefinitely.
-                // To work around it, we will wait until the application writes
-                // something to the standard output and then kill it.
-                while (true)
-                {
-                    if (stdOutBuffer.Length > 0)
-                    {
-                        cts.Cancel();
-                        break;
-                    }
-
-                    await Task.Delay(100, cts.Token);
-                }
-
-                await task;
-            }
-            catch (OperationCanceledException)
-            {
-                // It's expected to fail
-            }
-
-            var stdOut = stdOutBuffer.ToString();
-
-            // Assert
-            stdOut.Should().Contain("Attach debugger to");
-
-            TestOutput.WriteLine(stdOut);
         }
-
+        catch (OperationCanceledException ex) when (ex.CancellationToken == cts.Token)
-        [Fact]
-        public async Task Preview_directive_can_be_specified_to_print_command_input()
         {
-            // Arrange
+            // This means that the process was killed after it wrote the expected output
-            var commandType = DynamicCommandBuilder.Compile(
-                // language=cs
-                @"
-[Command(""cmd"")]
-public class Command : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
-
-            var application = new CliApplicationBuilder()
-                .AddCommand(commandType)
-                .UseConsole(FakeConsole)
-                .AllowPreviewMode()
-                .Build();
-
-            // Act
-            var exitCode = await application.RunAsync(
-                new[] {"[preview]", "cmd", "param", "-abc", "--option", "foo"},
-                new Dictionary<string, string>
-                {
-                    ["ENV_QOP"] = "hello",
-                    ["ENV_KIL"] = "world"
-                }
-            );
-
-            var stdOut = FakeConsole.ReadOutputString();
-
-            // Assert
-            exitCode.Should().Be(0);
-            stdOut.Should().ContainAllInOrder(
-                "cmd", "<param>", "[-a]", "[-b]", "[-c]", "[--option \"foo\"]",
-                "ENV_QOP", "=", "\"hello\"",
-                "ENV_KIL", "=", "\"world\""
-            );
         }
     }
-}
+
+    [Fact]
+    public async Task I_can_use_the_preview_directive_to_make_the_application_print_the_parsed_command_input()
+    {
+        // Arrange
+        var commandType = DynamicCommandBuilder.Compile(
+            // lang=csharp
+            """
+            [Command("cmd")]
+            public class Command : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """
+        );
+
+        var application = new CliApplicationBuilder()
+            .AddCommand(commandType)
+            .UseConsole(FakeConsole)
+            .AllowPreviewMode()
+            .Build();
+
+        // Act
+        var exitCode = await application.RunAsync(
+            ["[preview]", "cmd", "param", "-abc", "--option", "foo"],
+            new Dictionary<string, string> { ["ENV_QOP"] = "hello", ["ENV_KIL"] = "world" }
+        );
+
+        // Assert
+        exitCode.Should().Be(0);
+
+        var stdOut = FakeConsole.ReadOutputString();
+        stdOut
+            .Should()
+            .ContainAllInOrder(
+                "cmd",
+                "<param>",
+                "[-a]",
+                "[-b]",
+                "[-c]",
+                "[--option \"foo\"]",
+                "ENV_QOP",
+                "=",
+                "\"hello\"",
+                "ENV_KIL",
+                "=",
+                "\"world\""
+            );
+    }
+}

CliFx.Tests/EnvironmentSpecs.cs

@@ -10,251 +10,152 @@ using FluentAssertions;
 using Xunit;
 using Xunit.Abstractions;
 
-namespace CliFx.Tests
+namespace CliFx.Tests;
-{
-    public class EnvironmentSpecs : SpecsBase
-    {
-        public EnvironmentSpecs(ITestOutputHelper testOutput)
-            : base(testOutput)
-        {
-        }
 
-        [Fact]
+public class EnvironmentSpecs(ITestOutputHelper testOutput) : SpecsBase(testOutput)
-        public async Task Option_can_fall_back_to_an_environment_variable()
-        {
-            // Arrange
-            var commandType = DynamicCommandBuilder.Compile(
-                // language=cs
-                @"
-[Command]
-public class Command : ICommand
 {
-    [CommandOption(""foo"", IsRequired = true, EnvironmentVariable = ""ENV_FOO"")]
+    [Fact]
-    public string Foo { get; set; }
+    public async Task I_can_configure_an_option_to_fall_back_to_an_environment_variable_if_the_user_does_not_provide_the_corresponding_argument()
-    
-    public ValueTask ExecuteAsync(IConsole console)
     {
-        console.Output.WriteLine(Foo);
+        // Arrange
-        return default;
+        var commandType = DynamicCommandBuilder.Compile(
+            // lang=csharp
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo", EnvironmentVariable = "ENV_FOO")]
+                public string? Foo { get; init; }
+
+                [CommandOption("bar", EnvironmentVariable = "ENV_BAR")]
+                public string? Bar { get; init; }
+
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.WriteLine(Foo);
+                    console.WriteLine(Bar);
+
+                    return default;
+                }
+            }
+            """
+        );
+
+        var application = new CliApplicationBuilder()
+            .AddCommand(commandType)
+            .UseConsole(FakeConsole)
+            .Build();
+
+        // Act
+        var exitCode = await application.RunAsync(
+            ["--foo", "42"],
+            new Dictionary<string, string> { ["ENV_FOO"] = "100", ["ENV_BAR"] = "200" }
+        );
+
+        // Assert
+        exitCode.Should().Be(0);
+
+        var stdOut = FakeConsole.ReadOutputString();
+        stdOut.Trim().Should().ConsistOfLines("42", "200");
+    }
+
+    [Fact]
+    public async Task I_can_configure_an_option_bound_to_a_non_scalar_property_to_fall_back_to_an_environment_variable_if_the_user_does_not_provide_the_corresponding_argument()
+    {
+        // Arrange
+        var commandType = DynamicCommandBuilder.Compile(
+            // lang=csharp
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo", EnvironmentVariable = "ENV_FOO")]
+                public IReadOnlyList<string>? Foo { get; init; }
+
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    foreach (var i in Foo)
+                        console.WriteLine(i);
+
+                    return default;
+                }
+            }
+            """
+        );
+
+        var application = new CliApplicationBuilder()
+            .AddCommand(commandType)
+            .UseConsole(FakeConsole)
+            .Build();
+
+        // Act
+        var exitCode = await application.RunAsync(
+            Array.Empty<string>(),
+            new Dictionary<string, string> { ["ENV_FOO"] = $"bar{Path.PathSeparator}baz" }
+        );
+
+        // Assert
+        exitCode.Should().Be(0);
+
+        var stdOut = FakeConsole.ReadOutputString();
+        stdOut.Should().ConsistOfLines("bar", "baz");
+    }
+
+    [Fact]
+    public async Task I_can_configure_an_option_bound_to_a_scalar_property_to_fall_back_to_an_environment_variable_while_ignoring_path_separators()
+    {
+        // Arrange
+        var commandType = DynamicCommandBuilder.Compile(
+            // lang=csharp
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo", EnvironmentVariable = "ENV_FOO")]
+                public string? Foo { get; init; }
+
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.WriteLine(Foo);
+                    return default;
+                }
+            }
+            """
+        );
+
+        var application = new CliApplicationBuilder()
+            .AddCommand(commandType)
+            .UseConsole(FakeConsole)
+            .Build();
+
+        // Act
+        var exitCode = await application.RunAsync(
+            Array.Empty<string>(),
+            new Dictionary<string, string> { ["ENV_FOO"] = $"bar{Path.PathSeparator}baz" }
+        );
+
+        // Assert
+        exitCode.Should().Be(0);
+
+        var stdOut = FakeConsole.ReadOutputString();
+        stdOut.Trim().Should().Be($"bar{Path.PathSeparator}baz");
+    }
+
+    [Fact(Timeout = 15000)]
+    public async Task I_can_run_the_application_and_it_will_resolve_all_required_environment_variables_automatically()
+    {
+        // Ensures that the environment variables are properly obtained from
+        // System.Environment when they are not provided explicitly to CliApplication.
+
+        // Arrange
+        var command = Cli.Wrap(Dummy.Program.FilePath)
+            .WithArguments("env-test")
+            .WithEnvironmentVariables(e => e.Set("ENV_TARGET", "Mars"));
+
+        // Act
+        var result = await command.ExecuteBufferedAsync();
+
+        // Assert
+        result.StandardOutput.Trim().Should().Be("Hello Mars!");
     }
 }
-");
-
-            var application = new CliApplicationBuilder()
-                .AddCommand(commandType)
-                .UseConsole(FakeConsole)
-                .Build();
-
-            // Act
-            var exitCode = await application.RunAsync(
-                Array.Empty<string>(),
-                new Dictionary<string, string>
-                {
-                    ["ENV_FOO"] = "bar"
-                }
-            );
-
-            var stdOut = FakeConsole.ReadOutputString();
-
-            // Assert
-            exitCode.Should().Be(0);
-            stdOut.Trim().Should().Be("bar");
-        }
-
-        [Fact]
-        public async Task Option_does_not_fall_back_to_an_environment_variable_if_a_value_is_provided_through_arguments()
-        {
-            // Arrange
-            var commandType = DynamicCommandBuilder.Compile(
-                // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""foo"", EnvironmentVariable = ""ENV_FOO"")]
-    public string Foo { get; set; }
-    
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(Foo);
-        return default;
-    }
-}
-");
-
-            var application = new CliApplicationBuilder()
-                .AddCommand(commandType)
-                .UseConsole(FakeConsole)
-                .Build();
-
-            // Act
-            var exitCode = await application.RunAsync(
-                new[] {"--foo", "baz"},
-                new Dictionary<string, string>
-                {
-                    ["ENV_FOO"] = "bar"
-                }
-            );
-
-            var stdOut = FakeConsole.ReadOutputString();
-
-            // Assert
-            exitCode.Should().Be(0);
-            stdOut.Trim().Should().Be("baz");
-        }
-
-        [Fact]
-        public async Task Option_of_non_scalar_type_can_receive_multiple_values_from_an_environment_variable()
-        {
-            // Arrange
-            var commandType = DynamicCommandBuilder.Compile(
-                // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""foo"", EnvironmentVariable = ""ENV_FOO"")]
-    public IReadOnlyList<string> Foo { get; set; }
-    
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        foreach (var i in Foo)
-            console.Output.WriteLine(i);
-        
-        return default;
-    }
-}
-");
-
-            var application = new CliApplicationBuilder()
-                .AddCommand(commandType)
-                .UseConsole(FakeConsole)
-                .Build();
-
-            // Act
-            var exitCode = await application.RunAsync(
-                Array.Empty<string>(),
-                new Dictionary<string, string>
-                {
-                    ["ENV_FOO"] = $"bar{Path.PathSeparator}baz"
-                }
-            );
-
-            var stdOut = FakeConsole.ReadOutputString();
-
-            // Assert
-            exitCode.Should().Be(0);
-            stdOut.Should().ConsistOfLines(
-                "bar",
-                "baz"
-            );
-        }
-
-        [Fact]
-        public async Task Option_of_scalar_type_always_receives_a_single_value_from_an_environment_variable()
-        {
-            // Arrange
-            var commandType = DynamicCommandBuilder.Compile(
-                // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""foo"", EnvironmentVariable = ""ENV_FOO"")]
-    public string Foo { get; set; }
-    
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(Foo);
-        return default;
-    }
-}
-");
-
-            var application = new CliApplicationBuilder()
-                .AddCommand(commandType)
-                .UseConsole(FakeConsole)
-                .Build();
-
-            // Act
-            var exitCode = await application.RunAsync(
-                Array.Empty<string>(),
-                new Dictionary<string, string>
-                {
-                    ["ENV_FOO"] = $"bar{Path.PathSeparator}baz"
-                }
-            );
-
-            var stdOut = FakeConsole.ReadOutputString();
-
-            // Assert
-            exitCode.Should().Be(0);
-            stdOut.Trim().Should().Be($"bar{Path.PathSeparator}baz");
-        }
-
-        [Fact]
-        public async Task Environment_variables_are_matched_case_sensitively()
-        {
-            // Arrange
-            var commandType = DynamicCommandBuilder.Compile(
-                // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""foo"", EnvironmentVariable = ""ENV_FOO"")]
-    public string Foo { get; set; }
-    
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(Foo);
-        return default;
-    }
-}
-");
-
-            var application = new CliApplicationBuilder()
-                .AddCommand(commandType)
-                .UseConsole(FakeConsole)
-                .Build();
-
-            // Act
-            var exitCode = await application.RunAsync(
-                Array.Empty<string>(),
-                new Dictionary<string, string>
-                {
-                    ["ENV_foo"] = "baz",
-                    ["ENV_FOO"] = "bar",
-                    ["env_FOO"] = "qop"
-                }
-            );
-
-            var stdOut = FakeConsole.ReadOutputString();
-
-            // Assert
-            exitCode.Should().Be(0);
-            stdOut.Trim().Should().Be("bar");
-        }
-
-        [Fact]
-        public async Task Environment_variables_are_extracted_automatically()
-        {
-            // Ensures that the environment variables are properly obtained from
-            // System.Environment when they are not provided explicitly to CliApplication.
-
-            // Arrange
-            var command = Cli.Wrap("dotnet")
-                .WithArguments(a => a
-                    .Add(Dummy.Program.Location)
-                    .Add("env-test"))
-                .WithEnvironmentVariables(e => e
-                    .Set("ENV_TARGET", "Mars"));
-
-            // Act
-            var result = await command.ExecuteBufferedAsync();
-
-            // Assert
-            result.StandardOutput.Trim().Should().Be("Hello Mars!");
-        }
-    }
-}

CliFx.Tests/ErrorReportingSpecs.cs

@@ -7,199 +7,204 @@ using FluentAssertions;
 using Xunit;
 using Xunit.Abstractions;
 
-namespace CliFx.Tests
+namespace CliFx.Tests;
+
+public class ErrorReportingSpecs(ITestOutputHelper testOutput) : SpecsBase(testOutput)
 {
-    public class ErrorReportingSpecs : SpecsBase
+    [Fact]
+    public async Task I_can_throw_an_exception_in_a_command_to_report_an_error_with_a_stacktrace()
     {
-        public ErrorReportingSpecs(ITestOutputHelper testOutput)
+        // Arrange
-            : base(testOutput)
+        var commandType = DynamicCommandBuilder.Compile(
-        {
+            // lang=csharp
-        }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console) =>
+                    throw new Exception("Something went wrong");
+            }
+            """
+        );
 
-        [Fact]
+        var application = new CliApplicationBuilder()
-        public async Task Command_can_throw_an_exception_which_exits_with_a_stacktrace()
+            .AddCommand(commandType)
-        {
+            .UseConsole(FakeConsole)
-            // Arrange
+            .Build();
-            var commandType = DynamicCommandBuilder.Compile(
-                // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) =>
-        throw new Exception(""Something went wrong"");
-}
-");
 
-            var application = new CliApplicationBuilder()
+        // Act
-                .AddCommand(commandType)
+        var exitCode = await application.RunAsync(
-                .UseConsole(FakeConsole)
+            Array.Empty<string>(),
-                .Build();
+            new Dictionary<string, string>()
+        );
 
-            // Act
+        // Assert
-            var exitCode = await application.RunAsync(
+        exitCode.Should().NotBe(0);
-                Array.Empty<string>(),
-                new Dictionary<string, string>()
-            );
 
-            var stdOut = FakeConsole.ReadOutputString();
+        var stdOut = FakeConsole.ReadOutputString();
-            var stdErr = FakeConsole.ReadErrorString();
+        stdOut.Should().BeEmpty();
 
-            // Assert
+        var stdErr = FakeConsole.ReadErrorString();
-            exitCode.Should().NotBe(0);
+        stdErr
-            stdOut.Should().BeEmpty();
+            .Should()
-            stdErr.Should().ContainAllInOrder(
+            .ContainAllInOrder("System.Exception", "Something went wrong", "at", "CliFx.");
-                "System.Exception", "Something went wrong",
-                "at", "CliFx."
-            );
-        }
-
-        [Fact]
-        public async Task Command_can_throw_an_exception_with_an_inner_exception_which_exits_with_a_stacktrace()
-        {
-            // Arrange
-            var commandType = DynamicCommandBuilder.Compile(
-                // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) =>
-        throw new Exception(""Something went wrong"", new Exception(""Another exception""));
-}
-");
-
-            var application = new CliApplicationBuilder()
-                .AddCommand(commandType)
-                .UseConsole(FakeConsole)
-                .Build();
-
-            // Act
-            var exitCode = await application.RunAsync(
-                Array.Empty<string>(),
-                new Dictionary<string, string>()
-            );
-
-            var stdOut = FakeConsole.ReadOutputString();
-            var stdErr = FakeConsole.ReadErrorString();
-
-            // Assert
-            exitCode.Should().NotBe(0);
-            stdOut.Should().BeEmpty();
-            stdErr.Should().ContainAllInOrder(
-                "System.Exception", "Something went wrong",
-                "System.Exception", "Another exception",
-                "at", "CliFx."
-            );
-        }
-
-        [Fact]
-        public async Task Command_can_throw_a_special_exception_which_exits_with_specified_code_and_message()
-        {
-            // Arrange
-            var commandType = DynamicCommandBuilder.Compile(
-                // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) =>
-        throw new CommandException(""Something went wrong"", 69);
-}
-");
-
-            var application = new CliApplicationBuilder()
-                .AddCommand(commandType)
-                .UseConsole(FakeConsole)
-                .Build();
-
-            // Act
-            var exitCode = await application.RunAsync(
-                Array.Empty<string>(),
-                new Dictionary<string, string>()
-            );
-
-            var stdOut = FakeConsole.ReadOutputString();
-            var stdErr = FakeConsole.ReadErrorString();
-
-            // Assert
-            exitCode.Should().Be(69);
-            stdOut.Should().BeEmpty();
-            stdErr.Trim().Should().Be("Something went wrong");
-        }
-
-        [Fact]
-        public async Task Command_can_throw_a_special_exception_without_message_which_exits_with_a_stacktrace()
-        {
-            // Arrange
-            var commandType = DynamicCommandBuilder.Compile(
-                // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) =>
-        throw new CommandException("""", 69);
-}
-");
-
-            var application = new CliApplicationBuilder()
-                .AddCommand(commandType)
-                .UseConsole(FakeConsole)
-                .Build();
-
-            // Act
-            var exitCode = await application.RunAsync(
-                Array.Empty<string>(),
-                new Dictionary<string, string>()
-            );
-
-            var stdOut = FakeConsole.ReadOutputString();
-            var stdErr = FakeConsole.ReadErrorString();
-
-            // Assert
-            exitCode.Should().Be(69);
-            stdOut.Should().BeEmpty();
-            stdErr.Should().ContainAllInOrder(
-                "CliFx.Exceptions.CommandException",
-                "at", "CliFx."
-            );
-        }
-
-        [Fact]
-        public async Task Command_can_throw_a_special_exception_which_prints_help_text_before_exiting()
-        {
-            // Arrange
-            var commandType = DynamicCommandBuilder.Compile(
-                // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) =>
-        throw new CommandException(""Something went wrong"", 69, true);
-}
-");
-
-            var application = new CliApplicationBuilder()
-                .AddCommand(commandType)
-                .UseConsole(FakeConsole)
-                .SetDescription("This will be in help text")
-                .Build();
-
-            // Act
-            var exitCode = await application.RunAsync(
-                Array.Empty<string>(),
-                new Dictionary<string, string>()
-            );
-
-            var stdOut = FakeConsole.ReadOutputString();
-            var stdErr = FakeConsole.ReadErrorString();
-
-            // Assert
-            exitCode.Should().Be(69);
-            stdOut.Should().Contain("This will be in help text");
-            stdErr.Trim().Should().Be("Something went wrong");
-        }
     }
-}
+
+    [Fact]
+    public async Task I_can_throw_an_exception_with_an_inner_exception_in_a_command_to_report_an_error_with_a_stacktrace()
+    {
+        // Arrange
+        var commandType = DynamicCommandBuilder.Compile(
+            // lang=csharp
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console) =>
+                    throw new Exception("Something went wrong", new Exception("Another exception"));
+            }
+            """
+        );
+
+        var application = new CliApplicationBuilder()
+            .AddCommand(commandType)
+            .UseConsole(FakeConsole)
+            .Build();
+
+        // Act
+        var exitCode = await application.RunAsync(
+            Array.Empty<string>(),
+            new Dictionary<string, string>()
+        );
+
+        // Assert
+        exitCode.Should().NotBe(0);
+
+        var stdOut = FakeConsole.ReadOutputString();
+        stdOut.Should().BeEmpty();
+
+        var stdErr = FakeConsole.ReadErrorString();
+        stdErr
+            .Should()
+            .ContainAllInOrder(
+                "System.Exception",
+                "Something went wrong",
+                "System.Exception",
+                "Another exception",
+                "at",
+                "CliFx."
+            );
+    }
+
+    [Fact]
+    public async Task I_can_throw_an_exception_in_a_command_to_report_an_error_and_exit_with_the_specified_code()
+    {
+        // Arrange
+        var commandType = DynamicCommandBuilder.Compile(
+            // lang=csharp
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console) =>
+                    throw new CommandException("Something went wrong", 69);
+            }
+            """
+        );
+
+        var application = new CliApplicationBuilder()
+            .AddCommand(commandType)
+            .UseConsole(FakeConsole)
+            .Build();
+
+        // Act
+        var exitCode = await application.RunAsync(
+            Array.Empty<string>(),
+            new Dictionary<string, string>()
+        );
+
+        // Assert
+        exitCode.Should().Be(69);
+
+        var stdOut = FakeConsole.ReadOutputString();
+        stdOut.Should().BeEmpty();
+
+        var stdErr = FakeConsole.ReadErrorString();
+        stdErr.Trim().Should().Be("Something went wrong");
+    }
+
+    [Fact]
+    public async Task I_can_throw_an_exception_without_a_message_in_a_command_to_report_an_error_with_a_stacktrace()
+    {
+        // Arrange
+        var commandType = DynamicCommandBuilder.Compile(
+            // lang=csharp
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console) =>
+                    throw new CommandException("", 69);
+            }
+            """
+        );
+
+        var application = new CliApplicationBuilder()
+            .AddCommand(commandType)
+            .UseConsole(FakeConsole)
+            .Build();
+
+        // Act
+        var exitCode = await application.RunAsync(
+            Array.Empty<string>(),
+            new Dictionary<string, string>()
+        );
+
+        // Assert
+        exitCode.Should().Be(69);
+
+        var stdOut = FakeConsole.ReadOutputString();
+        stdOut.Should().BeEmpty();
+
+        var stdErr = FakeConsole.ReadErrorString();
+        stdErr.Should().ContainAllInOrder("CliFx.Exceptions.CommandException", "at", "CliFx.");
+    }
+
+    [Fact]
+    public async Task I_can_throw_an_exception_in_a_command_to_report_an_error_and_print_the_help_text()
+    {
+        // Arrange
+        var commandType = DynamicCommandBuilder.Compile(
+            // lang=csharp
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console) =>
+                    throw new CommandException("Something went wrong", 69, true);
+            }
+            """
+        );
+
+        var application = new CliApplicationBuilder()
+            .AddCommand(commandType)
+            .UseConsole(FakeConsole)
+            .SetDescription("This will be in help text")
+            .Build();
+
+        // Act
+        var exitCode = await application.RunAsync(
+            Array.Empty<string>(),
+            new Dictionary<string, string>()
+        );
+
+        // Assert
+        exitCode.Should().Be(69);
+
+        var stdOut = FakeConsole.ReadOutputString();
+        stdOut.Should().Contain("This will be in help text");
+
+        var stdErr = FakeConsole.ReadErrorString();
+        stdErr.Trim().Should().Be("Something went wrong");
+    }
+}