Update version

Closes #132

.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,42 @@
+name: 🐞 Bug report
+description: Report broken functionality.
+labels: [bug]
+
+body:
+- type: markdown
+  attributes:
+    value: |
+      🧐 **Guidelines:**
+
+      - Search through [existing issues](https://github.com/Tyrrrz/CliFx/issues?q=is%3Aissue) first to ensure that this bug has not been reported before.
+      - Write a descriptive title for your issue. Avoid generic or vague titles such as "Something's not working" or "A couple of problems".
+      - Keep your issue focused on one single problem. If you have multiple bug reports, please create separate issues for each of them.
+      - Provide as much context as possible in the details section. Include screenshots, screen recordings, links, references, or anything else you may consider relevant.
+      - If you want to ask a question instead of reporting a bug, please use [discussions](https://github.com/Tyrrrz/CliFx/discussions/new) instead.
+
+- type: input
+  attributes:
+    label: Version
+    description: Which version of CliFx does this bug affect?
+    placeholder: ver X.Y.Z
+  validations:
+    required: true
+
+- type: textarea
+  attributes:
+    label: Details
+    description: Clear and thorough explanation of the bug.
+    placeholder: I was doing X expecting Y to happen, but Z happened instead.
+  validations:
+    required: true
+
+- type: textarea
+  attributes:
+    label: Steps to reproduce
+    description: Minimum steps required to reproduce the bug.
+    placeholder: |
+      - Step 1
+      - Step 2
+      - Step 3
+  validations:
+    required: true

.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: 💬 Discord server
+    url: https://discord.gg/2SUWKFnHSm
+    about: Chat with the project community.
+  - name: 🗨 Discussions
+    url: https://github.com/Tyrrrz/CliFx/discussions/new
+    about: Ask and answer questions.

.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,13 @@
+name: main
+
+on: [push, pull_request]
+
+jobs:
+  main:
+    uses: Tyrrrz/.github/.github/workflows/nuget.yml@master
+    with:
+      dotnet-version: 7.0.x
+    secrets:
+      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+      NUGET_TOKEN: ${{ secrets.NUGET_TOKEN }}
+      DISCORD_WEBHOOK: ${{ secrets.DISCORD_WEBHOOK }}

Changelog.md

@@ -1,3 +1,71 @@
+### v2.3.1 (08-Dec-2022)
+
+- Added support for the `required` keyword introduced in C# 11. Command options bound to required properties are now marked as required by default (equivalent to setting `IsRequired = true` on the attribute). Also added analyzers that prevent marking an option or parameter non-required if it's bound to a required property.
+
+### v2.3 (12-Jul-2022)
+
+- Added console dimension properties `WindowWidth` and `WindowHeight` to `IConsole` interface and implementing classes.
+- Improved inline documentation for members of `IConsole` interface.
+
+### v2.2.6 (14-Jun-2022)
+
+- Added an overload of `CliApplicationBuilder.UseTypeActivator(...)` that accepts an instance of `IServiceProvider`. This slightly simplifies integration with many DI containers.
+- Fixed minor grammar mistakes in user-facing error messages.
+
+### v2.2.5 (10-May-2022)
+
+- Updated default value resolution for the application executable name. It will now resolve to `myapp.exe` instead of `dotnet myapp.dll` when the application is launched through the EXE apphost on Windows. On other platforms, or when running the application through the .NET CLI, the behavior will be the same as before.
+
+### v2.2.4 (22-Apr-2022)
+
+- Added more contextual information to analyzer diagnostics.
+- Fixed an issue where the analyzer incorrectly reported an error on converters that didn't directly match the target type but were compatible through known built-in conversions.
+- Fixed an issue where MSBuild produced a lot of analyzer-related warnings in certain circumstances.
+
+### v2.2.3 (17-Apr-2022)
+
+- Changed method signature of `IConsole.ReadKey()` to return `ConsoleKeyInfo` instead of `void`. The return type was originally defined as `void` by mistake. This change is source-backwards-compatible but may break on binary level if you were previously calling this method indirectly (i.e. through a library).
+- Added `FakeConsole.EnqueueKey(...)` to facilitate the testing of `IConsole.ReadKey()`. You can use this method to simulate key presses in your application.
+- Extended analyzers that verify the correctness of specified converters and validators. They now also ensure that the specified types are compatible with the type of the underlying property.
+- Improved diagnostics produced by analyzers. Where relevant, highlighted code is now limited to the property or type identifier, instead of the whole property or type declaration. Also extended the diagnostic messages with additional information.
+- Fixed an issue where throwing an exception inside a constructor of a command type resulted in an unrelated error message about the absence of a parameterless constructor.
+
+### v2.2.2 (30-Jan-2022)
+
+- Fixed an issue where `ConsoleWriter` and `ConsoleReader` were not properly thread-safe.
+- Fixed an issue where the analyzer failed to load under certain circumstances when running inside Visual Studio.
+
+### v2.2.1 (16-Jan-2022)
+
+- Fixed an issue which caused help text to not show default values for optional parameters. (Thanks [@AliReZa Sabouri](https://github.com/alirezanet))
+
+### v2.2 (11-Jan-2022)
+
+- Added support for optional parameters. A parameter can be marked as optional by setting `IsRequired = false` on the attribute. Only one parameter is allowed to be optional and such parameter must be the last in order. (Thanks [@AliReZa Sabouri](https://github.com/alirezanet))
+- Fixed an issue where parameters and options bound to properties implemented as default interface members were not working correctly. (Thanks [@AliReZa Sabouri](https://github.com/alirezanet))
+
+### v2.1 (04-Jan-2022)
+
+- Added `IConsole.Clear()` with corresponding implementations in `SystemConsole`, `FakeConsole`, and `FakeInMemoryConsole`. (Thanks [@Alex Rosenfeld](https://github.com/alexrosenfeld10))
+- Added `IConsole.ReadKey()` with corresponding implementations in `SystemConsole`, `FakeConsole`, and `FakeInMemoryConsole`. (Thanks [@Alex Rosenfeld](https://github.com/alexrosenfeld10))
+- Fixed an issue that caused parameters to appear out of order in the usage format section of the help text. (Thanks [@David Fallah](https://github.com/TAGC))
+
+### v2.0.6 (17-Jul-2021)
+
+- Fixed an issue where an exception thrown via reflection during parameter or option binding resulted in `Exception has been thrown by the target of an invocation` error instead of a more useful message. Such exceptions will now be unwrapped to provide better user experience.
+
+### v2.0.5 (09-Jul-2021)
+
+- Fixed an issue where calling `IConsole.Output.Encoding.EncodingName` and some other members threw an exception.
+- Added readme file to the package.
+
+### v2.0.4 (24-Apr-2021)
+
+- Fixed an issue where output and error streams in `SystemConsole` defaulted to UTF8 encoding with BOM when the application was running with UTF8 codepage. `ConsoleWriter` will now discard preamble from the specified encoding. This fix brings the behavior of `SystemConsole` in line with .NET's own `System.Console` which also discards preamble for output and error streams.
+- Fixed an issue where help text tried to show default values for parameters and options whose type does not override `ToString()` method.
+- Fixed an issue where help text didn't show default values for parameters and options whose type is an enumerable of nullable enums. (Thanks [@Robert Dailey](https://github.com/rcdailey))
+- Fixed an issue where specific parts of the help text weren't legible in some terminals due to low color resolution. Removed the usage of `ConsoleColor.DarkGray` in help text.
+
 ### v2.0.3 (09-Apr-2021)
 
 - Improved help text by showing valid values for non-scalar enum parameters and options. (Thanks [@Robert Dailey](https://github.com/rcdailey))
@@ -15,7 +83,7 @@
 ### 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.
+> 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.

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

@@ -1,11 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net5.0</TargetFramework>
-    <IsPackable>false</IsPackable>
-    <IsTestProject>true</IsTestProject>
-    <CollectCoverage>true</CollectCoverage>
-    <CoverletOutputFormat>opencover</CoverletOutputFormat>
+    <TargetFramework>net7.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
@@ -13,13 +9,14 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="GitHubActionsTestLogger" Version="1.2.0" />
-    <PackageReference Include="FluentAssertions" Version="5.10.3" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.9.1" />
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="3.4.0" />
-    <PackageReference Include="xunit" Version="2.4.0" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3" PrivateAssets="all" />
-    <PackageReference Include="coverlet.msbuild" Version="3.0.3" PrivateAssets="all" />
+    <PackageReference Include="Basic.Reference.Assemblies.Net70" Version="1.4.1" />
+    <PackageReference Include="GitHubActionsTestLogger" Version="2.0.1" PrivateAssets="all" />
+    <PackageReference Include="FluentAssertions" Version="6.8.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.4.0" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.4.0" />
+    <PackageReference Include="xunit" Version="2.4.2" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5" PrivateAssets="all" />
+    <PackageReference Include="coverlet.collector" Version="3.2.0" PrivateAssets="all" />
   </ItemGroup>
 
   <ItemGroup>

CliFx.Analyzers.Tests/CommandMustBeAnnotatedAnalyzerSpecs.cs

@@ -2,71 +2,78 @@
 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
+        // language=cs
+        const string code =
+            """
+            public class MyCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
-        [Fact]
-        public void Analyzer_reports_an_error_if_a_command_is_not_annotated_with_the_command_attribute()
-        {
-            // Arrange
-            // language=cs
-            const string code = @"
-public class MyCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(code);
+    }
 
-            // 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;
+            }
+            """;
 
-        [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);
+    }
 
-            // 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;
+            }
+            """;
 
-        [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);
+    }
 
-            // 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;
+            }
+            """;
 
-        [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);
-        }
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
     }
 }

CliFx.Analyzers.Tests/CommandMustImplementInterfaceAnalyzerSpecs.cs

@@ -2,57 +2,62 @@
 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
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand
+            {
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
-        [Fact]
-        public void Analyzer_reports_an_error_if_a_command_does_not_implement_ICommand_interface()
-        {
-            // Arrange
-            // language=cs
-            const string code = @"
-[Command]
-public class MyCommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(code);
+    }
 
-            // 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;
+            }
+            """;
 
-        [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);
+    }
 
-            // 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;
+            }
+            """;
 
-        [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);
-        }
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
     }
 }

CliFx.Analyzers.Tests/GeneralSpecs.cs

@@ -4,28 +4,27 @@ 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]
-        public void All_analyzers_have_unique_diagnostic_IDs()
-        {
-            // Arrange
-            var analyzers = typeof(AnalyzerBase)
-                .Assembly
-                .GetTypes()
-                .Where(t => !t.IsAbstract && t.IsAssignableTo(typeof(DiagnosticAnalyzer)))
-                .Select(t => (DiagnosticAnalyzer) Activator.CreateInstance(t)!)
-                .ToArray();
+        // Arrange
+        var analyzers = typeof(AnalyzerBase)
+            .Assembly
+            .GetTypes()
+            .Where(t => !t.IsAbstract && t.IsAssignableTo(typeof(DiagnosticAnalyzer)))
+            .Select(t => (DiagnosticAnalyzer) Activator.CreateInstance(t)!)
+            .ToArray();
 
-            // Act
-            var diagnosticIds = analyzers
-                .SelectMany(a => a.SupportedDiagnostics.Select(d => d.Id))
-                .ToArray();
+        // Act
+        var diagnosticIds = analyzers
+            .SelectMany(a => a.SupportedDiagnostics.Select(d => d.Id))
+            .ToArray();
 
-            // Assert
-            diagnosticIds.Should().OnlyHaveUniqueItems();
-        }
+        // Assert
+        diagnosticIds.Should().OnlyHaveUniqueItems();
     }
 }

CliFx.Analyzers.Tests/OptionMustBeInsideCommandAnalyzerSpecs.cs

@@ -2,79 +2,86 @@
 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
+        // language=cs
+        const string code =
+            """
+            public class MyClass
+            {
+                [CommandOption("foo")]
+                public string Foo { get; set; }
+            }
+            """;
 
-        [Fact]
-        public void Analyzer_reports_an_error_if_an_option_is_inside_a_class_that_is_not_a_command()
-        {
-            // Arrange
-            // language=cs
-            const string code = @"
-public class MyClass
-{
-    [CommandOption(""foo"")]
-    public string Foo { get; set; }
-}";
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(code);
+    }
 
-            // 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; }
 
-        [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;
+            }
+            """;
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
 
-            // 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; }
+            }
+            """;
 
-        [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);
+    }
 
-            // 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; }
 
-        [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;
+            }
+            """;
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
-
-            // Act & assert
-            Analyzer.Should().NotProduceDiagnostics(code);
-        }
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
     }
 }

CliFx.Analyzers.Tests/OptionMustBeRequiredIfPropertyRequiredAnalyzerSpecs.cs

@@ -0,0 +1,114 @@
+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
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption('f', IsRequired = false)]
+                public required string Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_required_option_is_bound_to_a_required_property()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption('f', IsRequired = true)]
+                public required 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_required_option_is_bound_to_a_non_required_property()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption('f', IsRequired = false)]
+                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_required_option_is_bound_to_a_non_required_property()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption('f', IsRequired = true)]
+                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 required string Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+}

CliFx.Analyzers.Tests/OptionMustHaveNameOrShortNameAnalyzerSpecs.cs

@@ -2,85 +2,92 @@
 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
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption(null)]
+                public string Foo { get; set; }
             
-        [Fact]
-        public void Analyzer_reports_an_error_if_an_option_does_not_have_a_name_or_short_name()
-        {
-            // Arrange
-            // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption(null)]
-    public string Foo { get; set; }
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(code);
+    }
 
-            // Act & assert
-            Analyzer.Should().ProduceDiagnostics(code);
-        }
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_an_option_has_a_name()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("foo")]
+                public string Foo { get; set; }
             
-        [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;
+            }
+            """;
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
 
-            // 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; }
             
-        [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;
+            }
+            """;
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
 
-            // 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; }
             
-        [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;
+            }
+            """;
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
-
-            // Act & assert
-            Analyzer.Should().NotProduceDiagnostics(code);
-        }
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
     }
 }

CliFx.Analyzers.Tests/OptionMustHaveUniqueNameAnalyzerSpecs.cs

@@ -2,91 +2,98 @@
 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
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("foo")]
+                public string Foo { get; set; }
             
-        [Fact]
-        public void Analyzer_reports_an_error_if_an_option_has_the_same_name_as_another_option()
-        {
-            // Arrange
-            // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption(""foo"")]
-    public string Foo { get; set; }
+                [CommandOption("foo")]
+                public string Bar { get; set; }
             
-    [CommandOption(""foo"")]
-    public string Bar { get; set; }
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(code);
+    }
 
-            // Act & assert
-            Analyzer.Should().ProduceDiagnostics(code);
-        }
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_an_option_has_a_unique_name()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("foo")]
+                public string Foo { get; set; }
             
-        [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; }
             
-    [CommandOption(""bar"")]
-    public string Bar { get; set; }
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
 
-            // 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; }
             
-        [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;
+            }
+            """;
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
 
-            // 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; }
             
-        [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;
+            }
+            """;
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
-
-            // Act & assert
-            Analyzer.Should().NotProduceDiagnostics(code);
-        }
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
     }
 }

CliFx.Analyzers.Tests/OptionMustHaveUniqueShortNameAnalyzerSpecs.cs

@@ -2,113 +2,122 @@
 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
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption('f')]
+                public string Foo { get; set; }
             
-        [Fact]
-        public void Analyzer_reports_an_error_if_an_option_has_the_same_short_name_as_another_option()
-        {
-            // Arrange
-            // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption('f')]
-    public string Foo { get; set; }
+                [CommandOption('f')]
+                public string Bar { get; set; }
             
-    [CommandOption('f')]
-    public string Bar { get; set; }
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(code);
+    }
 
-            // Act & assert
-            Analyzer.Should().ProduceDiagnostics(code);
-        }
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_an_option_has_a_unique_short_name()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption('f')]
+                public string Foo { get; set; }
             
-        [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; }
             
-    [CommandOption('b')]
-    public string Bar { get; set; }
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
 
-            // 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; }
             
-        [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; }
             
-    [CommandOption('F')]
-    public string Bar { get; set; }
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
 
-            // 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; }
             
-        [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;
+            }
+            """;
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
 
-            // 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; }
             
-        [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;
+            }
+            """;
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
-
-            // Act & assert
-            Analyzer.Should().NotProduceDiagnostics(code);
-        }
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
     }
 }

CliFx.Analyzers.Tests/OptionMustHaveValidConverterAnalyzerSpecs.cs

@@ -2,95 +2,180 @@
 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
+        // language=cs
+        const string code =
+            """
+            public class MyConverter
+            {
+                public string Convert(string rawValue) => rawValue;
+            }
             
-        [Fact]
-        public void Analyzer_reports_an_error_if_the_specified_option_converter_does_not_derive_from_BindingConverter()
-        {
-            // Arrange
-            // language=cs
-            const string code = @"
-public class MyConverter
-{
-    public string Convert(string rawValue) => rawValue;
-}
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("foo", Converter = typeof(MyConverter))]
+                public string Foo { get; set; }
             
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption(""foo"", Converter = typeof(MyConverter))]
-    public string Foo { get; set; }
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(code);
+    }
 
-            // Act & assert
-            Analyzer.Should().ProduceDiagnostics(code);
-        }
+    [Fact]
+    public void Analyzer_reports_an_error_if_an_option_has_a_converter_that_does_not_derive_from_a_compatible_BindingConverter()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            public class MyConverter : BindingConverter<int>
+            {
+                public override int Convert(string rawValue) => 42;
+            }
             
-        [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; }
             
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption(""foo"", Converter = typeof(MyConverter))]
-    public string Foo { get; set; }
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(code);
+    }
 
-            // Act & assert
-            Analyzer.Should().NotProduceDiagnostics(code);
-        }
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_an_option_has_a_converter_that_derives_from_a_compatible_BindingConverter()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            public class MyConverter : BindingConverter<string>
+            {
+                public override string Convert(string rawValue) => rawValue;
+            }
             
-        [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; }
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("foo", Converter = typeof(MyConverter))]
+                public string Foo { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
-            // Act & assert
-            Analyzer.Should().NotProduceDiagnostics(code);
-        }
+        // 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; }
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_nullable_option_has_a_converter_that_derives_from_a_compatible_BindingConverter()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            public class MyConverter : BindingConverter<int>
+            {
+                public override int Convert(string rawValue) => 42;
+            }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("foo", Converter = typeof(MyConverter))]
+                public int? Foo { get; set; }
             
-            // Act & assert
-            Analyzer.Should().NotProduceDiagnostics(code);
-        }
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_non_scalar_option_has_a_converter_that_derives_from_a_compatible_BindingConverter()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            public class MyConverter : BindingConverter<string>
+            {
+                public override string Convert(string rawValue) => rawValue;
+            }
+            
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("foo", Converter = typeof(MyConverter))]
+                public IReadOnlyList<string> Foo { get; set; }
+            
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_an_option_does_not_have_a_converter()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("foo")]
+                public string Foo { get; set; }
+            
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_on_a_property_that_is_not_an_option()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public string Foo { get; set; }
+            
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
     }
 }

CliFx.Analyzers.Tests/OptionMustHaveValidNameAnalyzerSpecs.cs

@@ -2,104 +2,113 @@
 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
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("f")]
+                public string Foo { get; set; }
             
-        [Fact]
-        public void Analyzer_reports_an_error_if_an_option_has_a_name_which_is_too_short()
-        {
-            // Arrange
-            // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption(""f"")]
-    public string Foo { get; set; }
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(code);
+    }
 
-            // Act & assert
-            Analyzer.Should().ProduceDiagnostics(code);
-        }
+    [Fact]
+    public void Analyzer_reports_an_error_if_an_option_has_a_name_that_starts_with_a_non_letter_character()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("1foo")]
+                public string Foo { get; set; }
             
-        [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;
+            }
+            """;
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(code);
+    }
 
-            // 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; }
             
-        [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;
+            }
+            """;
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
 
-            // 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; }
             
-        [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;
+            }
+            """;
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
 
-            // 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; }
             
-        [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;
+            }
+            """;
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
-
-            // Act & assert
-            Analyzer.Should().NotProduceDiagnostics(code);
-        }
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
     }
 }

CliFx.Analyzers.Tests/OptionMustHaveValidShortNameAnalyzerSpecs.cs

@@ -2,85 +2,92 @@
 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
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption('1')]
+                public string Foo { get; set; }
             
-        [Fact]
-        public void Analyzer_reports_an_error_if_an_option_has_a_short_name_which_is_not_a_letter_character()
-        {
-            // Arrange
-            // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption('1')]
-    public string Foo { get; set; }
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(code);
+    }
 
-            // Act & assert
-            Analyzer.Should().ProduceDiagnostics(code);
-        }
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_an_option_has_a_valid_short_name()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption('f')]
+                public string Foo { get; set; }
             
-        [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;
+            }
+            """;
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
 
-            // 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; }
             
-        [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;
+            }
+            """;
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
 
-            // 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; }
             
-        [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;
+            }
+            """;
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
-
-            // Act & assert
-            Analyzer.Should().NotProduceDiagnostics(code);
-        }
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
     }
 }

CliFx.Analyzers.Tests/OptionMustHaveValidValidatorsAnalyzerSpecs.cs

@@ -2,95 +2,128 @@
 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
+        // language=cs
+        const string code =
+            """
+            public class MyValidator
+            {
+                public void Validate(string value) {}
+            }
             
-        [Fact]
-        public void Analyzer_reports_an_error_if_one_of_the_specified_option_validators_does_not_derive_from_BindingValidator()
-        {
-            // Arrange
-            // language=cs
-            const string code = @"
-public class MyValidator
-{
-    public void Validate(string value) {}
-}
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("foo", Validators = new[] {typeof(MyValidator)})]
+                public string Foo { get; set; }
             
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption(""foo"", Validators = new[] {typeof(MyValidator)})]
-    public string Foo { get; set; }
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(code);
+    }
 
-            // Act & assert
-            Analyzer.Should().ProduceDiagnostics(code);
-        }
+    [Fact]
+    public void Analyzer_reports_an_error_if_an_option_has_a_validator_that_does_not_derive_from_a_compatible_BindingValidator()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            public class MyValidator : BindingValidator<int>
+            {
+                public override BindingValidationError Validate(int value) => Ok();
+            }
             
-        [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; }
             
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption(""foo"", Validators = new[] {typeof(MyValidator)})]
-    public string Foo { get; set; }
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(code);
+    }
 
-            // Act & assert
-            Analyzer.Should().NotProduceDiagnostics(code);
-        }
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_an_option_has_validators_that_all_derive_from_compatible_BindingValidators()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            public class MyValidator : BindingValidator<string>
+            {
+                public override BindingValidationError Validate(string value) => Ok();
+            }
             
-        [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; }
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("foo", Validators = new[] {typeof(MyValidator)})]
+                public string Foo { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
-            // Act & assert
-            Analyzer.Should().NotProduceDiagnostics(code);
-        }
+        // 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; }
+    [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;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
-            // Act & assert
-            Analyzer.Should().NotProduceDiagnostics(code);
-        }
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_on_a_property_that_is_not_an_option()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public string Foo { get; set; }
+            
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
     }
 }

CliFx.Analyzers.Tests/ParameterMustBeInsideCommandAnalyzerSpecs.cs

@@ -2,79 +2,86 @@
 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
+        // language=cs
+        const string code =
+            """
+            public class MyClass
+            {
+                [CommandParameter(0)]
+                public string Foo { get; set; }
+            }
+            """;
 
-        [Fact]
-        public void Analyzer_reports_an_error_if_a_parameter_is_inside_a_class_that_is_not_a_command()
-        {
-            // Arrange
-            // language=cs
-            const string code = @"
-public class MyClass
-{
-    [CommandParameter(0)]
-    public string Foo { get; set; }
-}";
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(code);
+    }
 
-            // 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; }
             
-        [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;
+            }
+            """;
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
 
-            // 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; }
+            }
+            """;
 
-        [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);
+    }
 
-            // 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; }
             
-        [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;
+            }
+            """;
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
-
-            // Act & assert
-            Analyzer.Should().NotProduceDiagnostics(code);
-        }
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
     }
 }

CliFx.Analyzers.Tests/ParameterMustBeLastIfNonRequiredAnalyzerSpecs.cs

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

CliFx.Analyzers.Tests/ParameterMustBeLastIfNonScalarAnalyzerSpecs.cs

@@ -2,94 +2,101 @@
 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
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0)]
+                public string[] Foo { get; set; }
             
-        [Fact]
-        public void Analyzer_reports_an_error_if_a_non_scalar_parameter_is_not_last_in_order()
-        {
-            // Arrange
-            // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandParameter(0)]
-    public string[] Foo { get; set; }
+                [CommandParameter(1)]
+                public string Bar { get; set; }
             
-    [CommandParameter(1)]
-    public string Bar { get; set; }
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(code);
+    }
 
-            // Act & assert
-            Analyzer.Should().ProduceDiagnostics(code);
-        }
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_non_scalar_parameter_is_the_last_in_order()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0)]
+                public string Foo { get; set; }
             
-        [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; }
             
-    [CommandParameter(1)]
-    public string[] Bar { get; set; }
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
 
-            // 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; }
             
-        [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; }
             
-    [CommandParameter(1)]
-    public string Bar { get; set; }
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
 
-            // 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; }
             
-        [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;
+            }
+            """;
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
-
-            // Act & assert
-            Analyzer.Should().NotProduceDiagnostics(code);
-        }
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
     }
 }

CliFx.Analyzers.Tests/ParameterMustBeRequiredIfPropertyRequiredAnalyzerSpecs.cs

@@ -0,0 +1,114 @@
+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
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0, IsRequired = false)]
+                public required string Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_required_parameter_is_bound_to_a_required_property()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0, IsRequired = true)]
+                public required 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_required_parameter_is_bound_to_a_non_required_property()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0, IsRequired = false)]
+                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_required_parameter_is_bound_to_a_non_required_property()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0, IsRequired = true)]
+                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 required string Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+}

CliFx.Analyzers.Tests/ParameterMustBeSingleIfNonRequiredAnalyzerSpecs.cs

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

CliFx.Analyzers.Tests/ParameterMustBeSingleIfNonScalarAnalyzerSpecs.cs

@@ -2,94 +2,101 @@
 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
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0)]
+                public string[] Foo { get; set; }
             
-        [Fact]
-        public void Analyzer_reports_an_error_if_more_than_one_non_scalar_parameters_are_defined()
-        {
-            // Arrange
-            // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandParameter(0)]
-    public string[] Foo { get; set; }
+                [CommandParameter(1)]
+                public string[] Bar { get; set; }
             
-    [CommandParameter(1)]
-    public string[] Bar { get; set; }
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(code);
+    }
 
-            // Act & assert
-            Analyzer.Should().ProduceDiagnostics(code);
-        }
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_only_one_non_scalar_parameter_is_defined()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0)]
+                public string Foo { get; set; }
             
-        [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; }
             
-    [CommandParameter(1)]
-    public string[] Bar { get; set; }
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
 
-            // 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; }
             
-        [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; }
             
-    [CommandParameter(1)]
-    public string Bar { get; set; }
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
 
-            // 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; }
             
-        [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;
+            }
+            """;
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
-
-            // Act & assert
-            Analyzer.Should().NotProduceDiagnostics(code);
-        }
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
     }
 }

CliFx.Analyzers.Tests/ParameterMustHaveUniqueNameAnalyzerSpecs.cs

@@ -2,72 +2,77 @@
 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
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0, Name = "foo")]
+                public string Foo { get; set; }
             
-        [Fact]
-        public void Analyzer_reports_an_error_if_a_parameter_has_the_same_name_as_another_parameter()
-        {
-            // Arrange
-            // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandParameter(0, Name = ""foo"")]
-    public string Foo { get; set; }
+                [CommandParameter(1, Name = "foo")]
+                public string Bar { get; set; }
             
-    [CommandParameter(1, Name = ""foo"")]
-    public string Bar { get; set; }
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(code);
+    }
 
-            // Act & assert
-            Analyzer.Should().ProduceDiagnostics(code);
-        }
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_parameter_has_unique_name()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0, Name = "foo")]
+                public string Foo { get; set; }
             
-        [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; }
             
-    [CommandParameter(1, Name = ""bar"")]
-    public string Bar { get; set; }
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
 
-            // 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; }
             
-        [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;
+            }
+            """;
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
-
-            // Act & assert
-            Analyzer.Should().NotProduceDiagnostics(code);
-        }
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
     }
 }

CliFx.Analyzers.Tests/ParameterMustHaveUniqueOrderAnalyzerSpecs.cs

@@ -2,72 +2,77 @@
 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
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0)]
+                public string Foo { get; set; }
             
-        [Fact]
-        public void Analyzer_reports_an_error_if_a_parameter_has_the_same_order_as_another_parameter()
-        {
-            // Arrange
-            // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandParameter(0)]
-    public string Foo { get; set; }
+                [CommandParameter(0)]
+                public string Bar { get; set; }
             
-    [CommandParameter(0)]
-    public string Bar { get; set; }
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(code);
+    }
 
-            // Act & assert
-            Analyzer.Should().ProduceDiagnostics(code);
-        }
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_parameter_has_unique_order()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0)]
+                public string Foo { get; set; }
             
-        [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; }
             
-    [CommandParameter(1)]
-    public string Bar { get; set; }
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
 
-            // 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; }
             
-        [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;
+            }
+            """;
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
-
-            // Act & assert
-            Analyzer.Should().NotProduceDiagnostics(code);
-        }
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
     }
 }

CliFx.Analyzers.Tests/ParameterMustHaveValidConverterAnalyzerSpecs.cs

@@ -2,95 +2,181 @@
 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
+        // language=cs
+        const string code =
+            """
+            public class MyConverter
+            {
+                public string Convert(string rawValue) => rawValue;
+            }
             
-        [Fact]
-        public void Analyzer_reports_an_error_if_the_specified_parameter_converter_does_not_derive_from_BindingConverter()
-        {
-            // Arrange
-            // language=cs
-            const string code = @"
-public class MyConverter
-{
-    public string Convert(string rawValue) => rawValue;
-}
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0, Converter = typeof(MyConverter))]
+                public string Foo { get; set; }
             
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandParameter(0, Converter = typeof(MyConverter))]
-    public string Foo { get; set; }
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(code);
+    }
 
-            // Act & assert
-            Analyzer.Should().ProduceDiagnostics(code);
-        }
+    [Fact]
+    public void Analyzer_reports_an_error_if_a_parameter_has_a_converter_that_does_not_derive_from_a_compatible_BindingConverter()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            public class MyConverter : BindingConverter<int>
+            {
+                public override int Convert(string rawValue) => 42;
+            }
             
-        [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; }
             
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandParameter(0, Converter = typeof(MyConverter))]
-    public string Foo { get; set; }
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
 
-            // Act & assert
-            Analyzer.Should().NotProduceDiagnostics(code);
-        }
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(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; }
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_parameter_has_a_converter_that_derives_from_a_compatible_BindingConverter()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            public class MyConverter : BindingConverter<string>
+            {
+                public override string Convert(string rawValue) => rawValue;
+            }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0, Converter = typeof(MyConverter))]
+                public string Foo { get; set; }
             
-            // Act & assert
-            Analyzer.Should().NotProduceDiagnostics(code);
-        }
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
-        [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; }
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_nullable_parameter_has_a_converter_that_derives_from_a_compatible_BindingConverter()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            public class MyConverter : BindingConverter<int>
+            {
+                public override int Convert(string rawValue) => 42;
+            }
             
-            // Act & assert
-            Analyzer.Should().NotProduceDiagnostics(code);
-        }
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("foo", Converter = typeof(MyConverter))]
+                public int? Foo { get; set; }
+            
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_non_scalar_parameter_has_a_converter_that_derives_from_a_compatible_BindingConverter()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            public class MyConverter : BindingConverter<string>
+            {
+                public override string Convert(string rawValue) => rawValue;
+            }
+            
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0, Converter = typeof(MyConverter))]
+                public IReadOnlyList<string> Foo { get; set; }
+            
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_parameter_does_not_have_a_converter()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0)]
+                public string Foo { get; set; }
+            
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_on_a_property_that_is_not_a_parameter()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public string Foo { get; set; }
+            
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
     }
 }

CliFx.Analyzers.Tests/ParameterMustHaveValidValidatorsAnalyzerSpecs.cs

@@ -2,95 +2,128 @@
 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
+        // language=cs
+        const string code =
+            """
+            public class MyValidator
+            {
+                public void Validate(string value) {}
+            }
             
-        [Fact]
-        public void Analyzer_reports_an_error_if_one_of_the_specified_parameter_validators_does_not_derive_from_BindingValidator()
-        {
-            // Arrange
-            // language=cs
-            const string code = @"
-public class MyValidator
-{
-    public void Validate(string value) {}
-}
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0, Validators = new[] {typeof(MyValidator)})]
+                public string Foo { get; set; }
             
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandParameter(0, Validators = new[] {typeof(MyValidator)})]
-    public string Foo { get; set; }
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(code);
+    }
 
-            // Act & assert
-            Analyzer.Should().ProduceDiagnostics(code);
-        }
+    [Fact]
+    public void Analyzer_reports_an_error_if_a_parameter_has_a_validator_that_does_not_derive_from_a_compatible_BindingValidator()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            public class MyValidator : BindingValidator<int>
+            {
+                public override BindingValidationError Validate(int value) => Ok();
+            }
             
-        [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; }
             
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandParameter(0, Validators = new[] {typeof(MyValidator)})]
-    public string Foo { get; set; }
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(code);
+    }
 
-            // Act & assert
-            Analyzer.Should().NotProduceDiagnostics(code);
-        }
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_parameter_has_validators_that_all_derive_from_compatible_BindingValidators()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            public class MyValidator : BindingValidator<string>
+            {
+                public override BindingValidationError Validate(string value) => Ok();
+            }
             
-        [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; }
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0, Validators = new[] {typeof(MyValidator)})]
+                public string Foo { get; set; }
             
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
-            // Act & assert
-            Analyzer.Should().NotProduceDiagnostics(code);
-        }
+        // 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; }
+    [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;
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
-            // Act & assert
-            Analyzer.Should().NotProduceDiagnostics(code);
-        }
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_on_a_property_that_is_not_a_parameter()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public string Foo { get; set; }
+            
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
     }
 }

CliFx.Analyzers.Tests/SystemConsoleShouldBeAvoidedAnalyzerSpecs.cs

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

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

CliFx.Analyzers/AnalyzerBase.cs

@@ -3,38 +3,37 @@ 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
-            );
+    protected Diagnostic CreateDiagnostic(Location location, params object?[]? messageArgs) =>
+        Diagnostic.Create(SupportedDiagnostic, location, messageArgs);
 
-            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);
-        }
+    public override void Initialize(AnalysisContext context)
+    {
+        context.EnableConcurrentExecution();
+        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
     }
 }

CliFx.Analyzers/CliFx.Analyzers.csproj

@@ -2,12 +2,21 @@
 
   <PropertyGroup>
     <TargetFramework>netstandard2.0</TargetFramework>
-    <Nullable>annotations</Nullable>
+    <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
+    <GenerateDependencyFile>true</GenerateDependencyFile>
     <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="Microsoft.CodeAnalysis.CSharp" Version="4.4.0" PrivateAssets="all" />
   </ItemGroup>
 
 </Project>

CliFx.Analyzers/CommandMustBeAnnotatedAnalyzer.cs

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

CliFx.Analyzers/CommandMustImplementInterfaceAnalyzer.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 CommandMustImplementInterfaceAnalyzer : AnalyzerBase
 {
-    [DiagnosticAnalyzer(LanguageNames.CSharp)]
-    public class CommandMustImplementInterfaceAnalyzer : AnalyzerBase
+    public CommandMustImplementInterfaceAnalyzer()
+        : base(
+            $"Commands must implement `{SymbolNames.CliFxCommandInterface}` interface",
+            $"This type must implement `{SymbolNames.CliFxCommandInterface}` interface in order to be a valid command.")
     {
-        public CommandMustImplementInterfaceAnalyzer()
-            : base(
-                $"Commands must implement `{SymbolNames.CliFxCommandInterface}` interface",
-                $"This type must implement `{SymbolNames.CliFxCommandInterface}` interface in order to be a valid command.")
+    }
+
+    private void Analyze(
+        SyntaxNodeAnalysisContext context,
+        ClassDeclarationSyntax classDeclaration,
+        ITypeSymbol type)
+    {
+        var hasCommandAttribute = type
+            .GetAttributes()
+            .Select(a => a.AttributeClass)
+            .Any(c => c.DisplayNameMatches(SymbolNames.CliFxCommandAttribute));
+
+        var implementsCommandInterface = type
+            .AllInterfaces
+            .Any(i => i.DisplayNameMatches(SymbolNames.CliFxCommandInterface));
+
+        // If the attribute is present, but the interface is not implemented,
+        // it's very likely a user error.
+        if (hasCommandAttribute && !implementsCommandInterface)
         {
-        }
-
-        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);
+            context.ReportDiagnostic(
+                CreateDiagnostic(classDeclaration.Identifier.GetLocation())
+            );
         }
     }
+
+    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 : ICommandMemberSymbol
 {
-    internal partial class CommandOptionSymbol
+    public IPropertySymbol Property { get; }
+
+    public string? Name { get; }
+
+    public char? ShortName { get; }
+
+    public bool? IsRequired { get; }
+
+    public ITypeSymbol? ConverterType { get; }
+
+    public IReadOnlyList<ITypeSymbol> ValidatorTypes { get; }
+
+    public CommandOptionSymbol(
+        IPropertySymbol property,
+        string? name,
+        char? shortName,
+        bool? isRequired,
+        ITypeSymbol? converterType,
+        IReadOnlyList<ITypeSymbol> validatorTypes)
     {
-        public string? Name { get; }
-
-        public char? ShortName { get; }
-
-        public ITypeSymbol? ConverterType { get; }
-
-        public IReadOnlyList<ITypeSymbol> ValidatorTypes { get; }
-
-        public CommandOptionSymbol(
-            string? name,
-            char? shortName,
-            ITypeSymbol? converterType,
-            IReadOnlyList<ITypeSymbol> validatorTypes)
-        {
-            Name = name;
-            ShortName = shortName;
-            ConverterType = converterType;
-            ValidatorTypes = validatorTypes;
-        }
-    }
-
-    internal partial class CommandOptionSymbol
-    {
-        private static AttributeData? TryGetOptionAttribute(IPropertySymbol property) =>
-            property
-                .GetAttributes()
-                .FirstOrDefault(a => a.AttributeClass.DisplayNameMatches(SymbolNames.CliFxCommandOptionAttribute));
-
-        private static CommandOptionSymbol FromAttribute(AttributeData attribute)
-        {
-            var name = attribute
-                .ConstructorArguments
-                .Where(a => a.Type.DisplayNameMatches("string") || a.Type.DisplayNameMatches("System.String"))
-                .Select(a => a.Value)
-                .FirstOrDefault() as string;
-
-            var shortName = attribute
-                .ConstructorArguments
-                .Where(a => a.Type.DisplayNameMatches("char") || a.Type.DisplayNameMatches("System.Char"))
-                .Select(a => a.Value)
-                .FirstOrDefault() as char?;
-
-            var converter = attribute
-                .NamedArguments
-                .Where(a => a.Key == "Converter")
-                .Select(a => a.Value.Value)
-                .Cast<ITypeSymbol?>()
-                .FirstOrDefault();
-
-            var validators = attribute
-                .NamedArguments
-                .Where(a => a.Key == "Validators")
-                .SelectMany(a => a.Value.Values)
-                .Select(c => c.Value)
-                .Cast<ITypeSymbol>()
-                .ToArray();
-
-            return new CommandOptionSymbol(name, shortName, converter, validators);
-        }
-
-        public static CommandOptionSymbol? TryResolve(IPropertySymbol property)
-        {
-            var attribute = TryGetOptionAttribute(property);
-
-            if (attribute is null)
-                return null;
-
-            return FromAttribute(attribute);
-        }
-
-        public static bool IsOptionProperty(IPropertySymbol property) =>
-            TryGetOptionAttribute(property) is not null;
+        Property = property;
+        Name = name;
+        ShortName = shortName;
+        IsRequired = isRequired;
+        ConverterType = converterType;
+        ValidatorTypes = validatorTypes;
     }
 }
+
+internal partial class CommandOptionSymbol
+{
+    private static AttributeData? TryGetOptionAttribute(IPropertySymbol property) => property
+        .GetAttributes()
+        .FirstOrDefault(a => a.AttributeClass?.DisplayNameMatches(SymbolNames.CliFxCommandOptionAttribute) == true);
+
+    public static CommandOptionSymbol? TryResolve(IPropertySymbol property)
+    {
+        var attribute = TryGetOptionAttribute(property);
+        if (attribute is null)
+            return null;
+
+        var name = attribute
+            .ConstructorArguments
+            .Where(a => a.Type?.SpecialType == SpecialType.System_String)
+            .Select(a => a.Value)
+            .FirstOrDefault() as string;
+
+        var shortName = attribute
+            .ConstructorArguments
+            .Where(a => a.Type?.SpecialType == SpecialType.System_Char)
+            .Select(a => a.Value)
+            .FirstOrDefault() as char?;
+
+        var isRequired = attribute
+            .NamedArguments
+            .Where(a => a.Key == "IsRequired")
+            .Select(a => a.Value.Value)
+            .FirstOrDefault() as bool?;
+
+        var converter = attribute
+            .NamedArguments
+            .Where(a => a.Key == "Converter")
+            .Select(a => a.Value.Value)
+            .Cast<ITypeSymbol?>()
+            .FirstOrDefault();
+
+        var validators = attribute
+            .NamedArguments
+            .Where(a => a.Key == "Validators")
+            .SelectMany(a => a.Value.Values)
+            .Select(c => c.Value)
+            .Cast<ITypeSymbol>()
+            .ToArray();
+
+        return new CommandOptionSymbol(property, name, shortName, isRequired, converter, validators);
+    }
+
+    public static bool IsOptionProperty(IPropertySymbol property) =>
+        TryGetOptionAttribute(property) is not null;
+}

CliFx.Analyzers/ObjectModel/CommandParameterSymbol.cs

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

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,12 @@
-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 CliFxCommandParameterAttribute = "CliFx.Attributes.CommandParameterAttribute";
-        public const string CliFxCommandOptionAttribute = "CliFx.Attributes.CommandOptionAttribute";
-        public const string CliFxConsoleInterface = "CliFx.Infrastructure.IConsole";
-        public const string CliFxBindingConverterInterface = "CliFx.Extensibility.IBindingConverter";
-        public const string CliFxBindingConverterClass = "CliFx.Extensibility.BindingConverter<T>";
-        public const string CliFxBindingValidatorInterface = "CliFx.Extensibility.IBindingValidator";
-        public const string CliFxBindingValidatorClass = "CliFx.Extensibility.BindingValidator<T>";
-    }
+    public const string CliFxCommandInterface = "CliFx.ICommand";
+    public const string CliFxCommandAttribute = "CliFx.Attributes.CommandAttribute";
+    public const string CliFxCommandParameterAttribute = "CliFx.Attributes.CommandParameterAttribute";
+    public const string CliFxCommandOptionAttribute = "CliFx.Attributes.CommandOptionAttribute";
+    public const string CliFxConsoleInterface = "CliFx.Infrastructure.IConsole";
+    public const string CliFxBindingConverterClass = "CliFx.Extensibility.BindingConverter<T>";
+    public const string CliFxBindingValidatorClass = "CliFx.Extensibility.BindingValidator<T>";
 }

CliFx.Analyzers/OptionMustBeInsideCommandAnalyzer.cs

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

CliFx.Analyzers/OptionMustBeRequiredIfPropertyRequiredAnalyzer.cs

@@ -0,0 +1,49 @@
+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
+{
+    public OptionMustBeRequiredIfPropertyRequiredAnalyzer()
+        : base(
+            "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,38 @@ 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
 {
-    [DiagnosticAnalyzer(LanguageNames.CSharp)]
-    public class OptionMustHaveNameOrShortNameAnalyzer : AnalyzerBase
+    public OptionMustHaveNameOrShortNameAnalyzer()
+        : base(
+            "Options must have either a name or short name specified",
+            "This option must have either a name or short name specified.")
     {
-        public OptionMustHaveNameOrShortNameAnalyzer()
-            : base(
-                "Options must have either a name or short name specified",
-                "This option must have either a name or short name specified.")
-        {
-        }
+    }
 
-        private void Analyze(
-            SyntaxNodeAnalysisContext context,
-            PropertyDeclarationSyntax propertyDeclaration,
-            IPropertySymbol property)
-        {
-            var option = CommandOptionSymbol.TryResolve(property);
-            if (option is null)
-                return;
+    private void Analyze(
+        SyntaxNodeAnalysisContext context,
+        PropertyDeclarationSyntax propertyDeclaration,
+        IPropertySymbol property)
+    {
+        var option = CommandOptionSymbol.TryResolve(property);
+        if (option is null)
+            return;
 
-            if (string.IsNullOrWhiteSpace(option.Name) && option.ShortName is null)
-            {
-                context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
-            }
-        }
-
-        public override void Initialize(AnalysisContext context)
+        if (string.IsNullOrWhiteSpace(option.Name) && option.ShortName is null)
         {
-            base.Initialize(context);
-            context.HandlePropertyDeclaration(Analyze);
+            context.ReportDiagnostic(
+                CreateDiagnostic(propertyDeclaration.Identifier.GetLocation())
+            );
         }
     }
+
+    public override void Initialize(AnalysisContext context)
+    {
+        base.Initialize(context);
+        context.HandlePropertyDeclaration(Analyze);
+    }
 }

CliFx.Analyzers/OptionMustHaveUniqueNameAnalyzer.cs

@@ -6,60 +6,67 @@ 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
 {
-    [DiagnosticAnalyzer(LanguageNames.CSharp)]
-    public class OptionMustHaveUniqueNameAnalyzer : AnalyzerBase
+    public OptionMustHaveUniqueNameAnalyzer()
+        : base(
+            "Options must have unique names",
+            "This option's name must be unique within the command (comparison IS NOT case sensitive). " +
+            "Specified name: `{0}`. " +
+            "Property bound to another option with the same name: `{1}`.")
     {
-        public OptionMustHaveUniqueNameAnalyzer()
-            : base(
-                "Options must have unique names",
-                "This option's name must be unique within the command (comparison IS NOT case sensitive).")
+    }
+
+    private void Analyze(
+        SyntaxNodeAnalysisContext context,
+        PropertyDeclarationSyntax propertyDeclaration,
+        IPropertySymbol property)
+    {
+        if (property.ContainingType is null)
+            return;
+
+        var option = CommandOptionSymbol.TryResolve(property);
+        if (option is null)
+            return;
+
+        if (string.IsNullOrWhiteSpace(option.Name))
+            return;
+
+        var otherProperties = property
+            .ContainingType
+            .GetMembers()
+            .OfType<IPropertySymbol>()
+            .Where(m => !m.Equals(property, SymbolEqualityComparer.Default))
+            .ToArray();
+
+        foreach (var otherProperty in otherProperties)
         {
-        }
+            var otherOption = CommandOptionSymbol.TryResolve(otherProperty);
+            if (otherOption is null)
+                continue;
 
-        private void Analyze(
-            SyntaxNodeAnalysisContext context,
-            PropertyDeclarationSyntax propertyDeclaration,
-            IPropertySymbol property)
-        {
-            if (property.ContainingType is null)
-                return;
+            if (string.IsNullOrWhiteSpace(otherOption.Name))
+                continue;
 
-            var option = CommandOptionSymbol.TryResolve(property);
-            if (option is null)
-                return;
-
-            if (string.IsNullOrWhiteSpace(option.Name))
-                return;
-
-            var otherProperties = property
-                .ContainingType
-                .GetMembers()
-                .OfType<IPropertySymbol>()
-                .Where(m => !m.Equals(property, SymbolEqualityComparer.Default))
-                .ToArray();
-
-            foreach (var otherProperty in otherProperties)
+            if (string.Equals(option.Name, otherOption.Name, StringComparison.OrdinalIgnoreCase))
             {
-                var otherOption = CommandOptionSymbol.TryResolve(otherProperty);
-                if (otherOption is null)
-                    continue;
-
-                if (string.IsNullOrWhiteSpace(otherOption.Name))
-                    continue;
-
-                if (string.Equals(option.Name, otherOption.Name, StringComparison.OrdinalIgnoreCase))
-                {
-                    context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
-                }
+                context.ReportDiagnostic(
+                    CreateDiagnostic(
+                        propertyDeclaration.Identifier.GetLocation(),
+                        option.Name,
+                        otherProperty.Name
+                    )
+                );
             }
         }
+    }
 
-        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,60 +5,67 @@ 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
 {
-    [DiagnosticAnalyzer(LanguageNames.CSharp)]
-    public class OptionMustHaveUniqueShortNameAnalyzer : AnalyzerBase
+    public OptionMustHaveUniqueShortNameAnalyzer()
+        : base(
+            "Options must have unique short names",
+            "This option's short name must be unique within the command (comparison IS case sensitive). " +
+            "Specified short name: `{0}` " +
+            "Property bound to another option with the same short name: `{1}`.")
     {
-        public OptionMustHaveUniqueShortNameAnalyzer()
-            : base(
-                "Options must have unique short names",
-                "This option's short name must be unique within the command (comparison IS case sensitive).")
+    }
+
+    private void Analyze(
+        SyntaxNodeAnalysisContext context,
+        PropertyDeclarationSyntax propertyDeclaration,
+        IPropertySymbol property)
+    {
+        if (property.ContainingType is null)
+            return;
+
+        var option = CommandOptionSymbol.TryResolve(property);
+        if (option is null)
+            return;
+
+        if (option.ShortName is null)
+            return;
+
+        var otherProperties = property
+            .ContainingType
+            .GetMembers()
+            .OfType<IPropertySymbol>()
+            .Where(m => !m.Equals(property, SymbolEqualityComparer.Default))
+            .ToArray();
+
+        foreach (var otherProperty in otherProperties)
         {
-        }
+            var otherOption = CommandOptionSymbol.TryResolve(otherProperty);
+            if (otherOption is null)
+                continue;
 
-        private void Analyze(
-            SyntaxNodeAnalysisContext context,
-            PropertyDeclarationSyntax propertyDeclaration,
-            IPropertySymbol property)
-        {
-            if (property.ContainingType is null)
-                return;
+            if (otherOption.ShortName is null)
+                continue;
 
-            var option = CommandOptionSymbol.TryResolve(property);
-            if (option is null)
-                return;
-
-            if (option.ShortName is null)
-                return;
-
-            var otherProperties = property
-                .ContainingType
-                .GetMembers()
-                .OfType<IPropertySymbol>()
-                .Where(m => !m.Equals(property, SymbolEqualityComparer.Default))
-                .ToArray();
-
-            foreach (var otherProperty in otherProperties)
+            if (option.ShortName == otherOption.ShortName)
             {
-                var otherOption = CommandOptionSymbol.TryResolve(otherProperty);
-                if (otherOption is null)
-                    continue;
-
-                if (otherOption.ShortName is null)
-                    continue;
-
-                if (option.ShortName == otherOption.ShortName)
-                {
-                    context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
-                }
+                context.ReportDiagnostic(
+                    CreateDiagnostic(
+                        propertyDeclaration.Identifier.GetLocation(),
+                        option.ShortName,
+                        otherProperty.Name
+                    )
+                );
             }
         }
+    }
 
-        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,58 @@ 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
 {
-    [DiagnosticAnalyzer(LanguageNames.CSharp)]
-    public class OptionMustHaveValidConverterAnalyzer : AnalyzerBase
+    public OptionMustHaveValidConverterAnalyzer()
+        : base(
+            $"Option converters must derive from `{SymbolNames.CliFxBindingConverterClass}`",
+            $"Converter specified for this option must derive from a compatible `{SymbolNames.CliFxBindingConverterClass}`.")
     {
-        public OptionMustHaveValidConverterAnalyzer()
-            : base(
-                $"Option converters must derive from `{SymbolNames.CliFxBindingConverterClass}`",
-                $"Converter specified for this option must derive from `{SymbolNames.CliFxBindingConverterClass}`.")
+    }
+
+    private void Analyze(
+        SyntaxNodeAnalysisContext context,
+        PropertyDeclarationSyntax propertyDeclaration,
+        IPropertySymbol property)
+    {
+        var option = CommandOptionSymbol.TryResolve(property);
+        if (option is null)
+            return;
+
+        if (option.ConverterType is null)
+            return;
+
+        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)
         {
-        }
-
-        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);
+            context.ReportDiagnostic(
+                CreateDiagnostic(propertyDeclaration.Identifier.GetLocation())
+            );
         }
     }
+
+    public override void Initialize(AnalysisContext context)
+    {
+        base.Initialize(context);
+        context.HandlePropertyDeclaration(Analyze);
+    }
 }

CliFx.Analyzers/OptionMustHaveValidNameAnalyzer.cs

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

CliFx.Analyzers/OptionMustHaveValidShortNameAnalyzer.cs

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

CliFx.Analyzers/OptionMustHaveValidValidatorsAnalyzer.cs

@@ -5,48 +5,55 @@ 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
 {
-    [DiagnosticAnalyzer(LanguageNames.CSharp)]
-    public class OptionMustHaveValidValidatorsAnalyzer : AnalyzerBase
+    public OptionMustHaveValidValidatorsAnalyzer()
+        : base(
+            $"Option validators must derive from `{SymbolNames.CliFxBindingValidatorClass}`",
+            $"Each validator specified for this option must derive from a compatible `{SymbolNames.CliFxBindingValidatorClass}`.")
     {
-        public OptionMustHaveValidValidatorsAnalyzer()
-            : base(
-                $"Option validators must derive from `{SymbolNames.CliFxBindingValidatorClass}`",
-                $"All validators specified for this option must derive from `{SymbolNames.CliFxBindingValidatorClass}`.")
-        {
-        }
+    }
 
-        private void Analyze(
-            SyntaxNodeAnalysisContext context,
-            PropertyDeclarationSyntax propertyDeclaration,
-            IPropertySymbol property)
-        {
-            var option = CommandOptionSymbol.TryResolve(property);
-            if (option is null)
-                return;
+    private void Analyze(
+        SyntaxNodeAnalysisContext context,
+        PropertyDeclarationSyntax propertyDeclaration,
+        IPropertySymbol property)
+    {
+        var option = CommandOptionSymbol.TryResolve(property);
+        if (option is null)
+            return;
 
-            foreach (var validatorType in option.ValidatorTypes)
+        foreach (var validatorType in option.ValidatorTypes)
+        {
+            var validatorValueType = validatorType
+                .GetBaseTypes()
+                .FirstOrDefault(t => t.ConstructedFrom.DisplayNameMatches(SymbolNames.CliFxBindingValidatorClass))?
+                .TypeArguments
+                .FirstOrDefault();
+
+            // Value passed to the validator must be assignable from the property type
+            var isCompatible =
+                validatorValueType is not null &&
+                context.Compilation.IsAssignable(property.Type, validatorValueType);
+
+            if (!isCompatible)
             {
-                // We check against an internal interface because checking against a generic class is a pain
-                var validatorImplementsInterface = validatorType
-                    .AllInterfaces
-                    .Any(s => s.DisplayNameMatches(SymbolNames.CliFxBindingValidatorInterface));
+                context.ReportDiagnostic(
+                    CreateDiagnostic(propertyDeclaration.Identifier.GetLocation())
+                );
 
-                if (!validatorImplementsInterface)
-                {
-                    context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
-
-                    // No need to report multiple identical diagnostics on the same node
-                    break;
-                }
+                // 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,47 +5,48 @@ 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
 {
-    [DiagnosticAnalyzer(LanguageNames.CSharp)]
-    public class ParameterMustBeInsideCommandAnalyzer : AnalyzerBase
+    public ParameterMustBeInsideCommandAnalyzer()
+        : base(
+            "Parameters must be defined inside commands",
+            $"This parameter must be defined inside a class that implements `{SymbolNames.CliFxCommandInterface}`.")
     {
-        public ParameterMustBeInsideCommandAnalyzer()
-            : base(
-                "Parameters must be defined inside commands",
-                $"This parameter must be defined inside a class that implements `{SymbolNames.CliFxCommandInterface}`.")
+    }
+
+    private void Analyze(
+        SyntaxNodeAnalysisContext context,
+        PropertyDeclarationSyntax propertyDeclaration,
+        IPropertySymbol property)
+    {
+        if (property.ContainingType is null)
+            return;
+
+        if (property.ContainingType.IsAbstract)
+            return;
+
+        if (!CommandParameterSymbol.IsParameterProperty(property))
+            return;
+
+        var isInsideCommand = property
+            .ContainingType
+            .AllInterfaces
+            .Any(i => i.DisplayNameMatches(SymbolNames.CliFxCommandInterface));
+
+        if (!isInsideCommand)
         {
-        }
-
-        private void Analyze(
-            SyntaxNodeAnalysisContext context,
-            PropertyDeclarationSyntax propertyDeclaration,
-            IPropertySymbol property)
-        {
-            if (property.ContainingType is null)
-                return;
-
-            if (property.ContainingType.IsAbstract)
-                return;
-
-            if (!CommandParameterSymbol.IsParameterProperty(property))
-                return;
-
-            var isInsideCommand = property
-                .ContainingType
-                .AllInterfaces
-                .Any(s => s.DisplayNameMatches(SymbolNames.CliFxCommandInterface));
-
-            if (!isInsideCommand)
-            {
-                context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
-            }
-        }
-
-        public override void Initialize(AnalysisContext context)
-        {
-            base.Initialize(context);
-            context.HandlePropertyDeclaration(Analyze);
+            context.ReportDiagnostic(
+                CreateDiagnostic(propertyDeclaration.Identifier.GetLocation())
+            );
         }
     }
+
+    public override void Initialize(AnalysisContext context)
+    {
+        base.Initialize(context);
+        context.HandlePropertyDeclaration(Analyze);
+    }
 }

CliFx.Analyzers/ParameterMustBeLastIfNonRequiredAnalyzer.cs

@@ -0,0 +1,66 @@
+using System.Linq;
+using CliFx.Analyzers.ObjectModel;
+using CliFx.Analyzers.Utils.Extensions;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace CliFx.Analyzers;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public class ParameterMustBeLastIfNonRequiredAnalyzer : AnalyzerBase
+{
+    public ParameterMustBeLastIfNonRequiredAnalyzer()
+        : base(
+            "Parameters marked as non-required must be the last in order",
+            "This parameter is non-required so it must be the last in order (its order must be highest within the command). " +
+            "Property bound to another non-required parameter: `{0}`.")
+    {
+    }
+
+    private void Analyze(
+        SyntaxNodeAnalysisContext context,
+        PropertyDeclarationSyntax propertyDeclaration,
+        IPropertySymbol property)
+    {
+        if (property.ContainingType is null)
+            return;
+
+        var parameter = CommandParameterSymbol.TryResolve(property);
+        if (parameter is null)
+            return;
+
+        if (parameter.IsRequired != false)
+            return;
+
+        var otherProperties = property
+            .ContainingType
+            .GetMembers()
+            .OfType<IPropertySymbol>()
+            .Where(m => !m.Equals(property, SymbolEqualityComparer.Default))
+            .ToArray();
+
+        foreach (var otherProperty in otherProperties)
+        {
+            var otherParameter = CommandParameterSymbol.TryResolve(otherProperty);
+            if (otherParameter is null)
+                continue;
+
+            if (otherParameter.Order > parameter.Order)
+            {
+                context.ReportDiagnostic(
+                    CreateDiagnostic(
+                        propertyDeclaration.Identifier.GetLocation(),
+                        otherProperty.Name
+                    )
+                );
+            }
+        }
+    }
+
+    public override void Initialize(AnalysisContext context)
+    {
+        base.Initialize(context);
+        context.HandlePropertyDeclaration(Analyze);
+    }
+}

CliFx.Analyzers/ParameterMustBeLastIfNonScalarAnalyzer.cs

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

CliFx.Analyzers/ParameterMustBeSingleIfNonScalarAnalyzer.cs

@@ -5,62 +5,62 @@ 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
 {
-    [DiagnosticAnalyzer(LanguageNames.CSharp)]
-    public class ParameterMustBeSingleIfNonScalarAnalyzer : AnalyzerBase
+    public ParameterMustBeSingleIfNonScalarAnalyzer()
+        : base(
+            "Parameters of non-scalar types are limited to one per command",
+            "This parameter has a non-scalar type so it must be the only such parameter in the command. " +
+            "Property bound to another non-scalar parameter: `{0}`.")
     {
-        public ParameterMustBeSingleIfNonScalarAnalyzer()
-            : base(
-                "Parameters of non-scalar types are limited to one per command",
-                "This parameter has a non-scalar type so it must be the only such parameter in the command.")
+    }
+
+    private void Analyze(
+        SyntaxNodeAnalysisContext context,
+        PropertyDeclarationSyntax propertyDeclaration,
+        IPropertySymbol property)
+    {
+        if (property.ContainingType is null)
+            return;
+
+        var parameter = CommandParameterSymbol.TryResolve(property);
+        if (parameter is null)
+            return;
+
+        if (parameter.IsScalar())
+            return;
+
+        var otherProperties = property
+            .ContainingType
+            .GetMembers()
+            .OfType<IPropertySymbol>()
+            .Where(m => !m.Equals(property, SymbolEqualityComparer.Default))
+            .ToArray();
+
+        foreach (var otherProperty in otherProperties)
         {
-        }
+            var otherParameter = CommandParameterSymbol.TryResolve(otherProperty);
+            if (otherParameter is null)
+                continue;
 
-        private static bool IsScalar(ITypeSymbol type) =>
-            type.DisplayNameMatches("string") ||
-            type.DisplayNameMatches("System.String") ||
-            !type.AllInterfaces
-                .Select(i => i.ConstructedFrom)
-                .Any(s => s.DisplayNameMatches("System.Collections.Generic.IEnumerable<T>"));
-
-        private void Analyze(
-            SyntaxNodeAnalysisContext context,
-            PropertyDeclarationSyntax propertyDeclaration,
-            IPropertySymbol property)
-        {
-            if (property.ContainingType is null)
-                return;
-
-            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 (!otherParameter.IsScalar())
             {
-                if (!CommandParameterSymbol.IsParameterProperty(otherProperty))
-                    continue;
-
-                if (!IsScalar(otherProperty.Type))
-                {
-                    context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
-                }
+                context.ReportDiagnostic(
+                    CreateDiagnostic(
+                        propertyDeclaration.Identifier.GetLocation(),
+                        otherProperty.Name
+                    )
+                );
             }
         }
+    }
 
-        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,60 +6,67 @@ 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
 {
-    [DiagnosticAnalyzer(LanguageNames.CSharp)]
-    public class ParameterMustHaveUniqueNameAnalyzer : AnalyzerBase
+    public ParameterMustHaveUniqueNameAnalyzer()
+        : base(
+            "Parameters must have unique names",
+            "This parameter's name must be unique within the command (comparison IS NOT case sensitive). " +
+            "Specified name: `{0}`. " +
+            "Property bound to another parameter with the same name: `{1}`.")
     {
-        public ParameterMustHaveUniqueNameAnalyzer()
-            : base(
-                "Parameters must have unique names",
-                "This parameter's name must be unique within the command (comparison IS NOT case sensitive).")
+    }
+
+    private void Analyze(
+        SyntaxNodeAnalysisContext context,
+        PropertyDeclarationSyntax propertyDeclaration,
+        IPropertySymbol property)
+    {
+        if (property.ContainingType is null)
+            return;
+
+        var parameter = CommandParameterSymbol.TryResolve(property);
+        if (parameter is null)
+            return;
+
+        if (string.IsNullOrWhiteSpace(parameter.Name))
+            return;
+
+        var otherProperties = property
+            .ContainingType
+            .GetMembers()
+            .OfType<IPropertySymbol>()
+            .Where(m => !m.Equals(property, SymbolEqualityComparer.Default))
+            .ToArray();
+
+        foreach (var otherProperty in otherProperties)
         {
-        }
+            var otherParameter = CommandParameterSymbol.TryResolve(otherProperty);
+            if (otherParameter is null)
+                continue;
 
-        private void Analyze(
-            SyntaxNodeAnalysisContext context,
-            PropertyDeclarationSyntax propertyDeclaration,
-            IPropertySymbol property)
-        {
-            if (property.ContainingType is null)
-                return;
+            if (string.IsNullOrWhiteSpace(otherParameter.Name))
+                continue;
 
-            var parameter = CommandParameterSymbol.TryResolve(property);
-            if (parameter is null)
-                return;
-
-            if (string.IsNullOrWhiteSpace(parameter.Name))
-                return;
-
-            var otherProperties = property
-                .ContainingType
-                .GetMembers()
-                .OfType<IPropertySymbol>()
-                .Where(m => !m.Equals(property, SymbolEqualityComparer.Default))
-                .ToArray();
-
-            foreach (var otherProperty in otherProperties)
+            if (string.Equals(parameter.Name, otherParameter.Name, StringComparison.OrdinalIgnoreCase))
             {
-                var otherParameter = CommandParameterSymbol.TryResolve(otherProperty);
-                if (otherParameter is null)
-                    continue;
-
-                if (string.IsNullOrWhiteSpace(otherParameter.Name))
-                    continue;
-
-                if (string.Equals(parameter.Name, otherParameter.Name, StringComparison.OrdinalIgnoreCase))
-                {
-                    context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
-                }
+                context.ReportDiagnostic(
+                    CreateDiagnostic(
+                        propertyDeclaration.Identifier.GetLocation(),
+                        parameter.Name,
+                        otherProperty.Name
+                    )
+                );
             }
         }
+    }
 
-        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,54 +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 ParameterMustHaveUniqueOrderAnalyzer : AnalyzerBase
 {
-    [DiagnosticAnalyzer(LanguageNames.CSharp)]
-    public class ParameterMustHaveUniqueOrderAnalyzer : AnalyzerBase
+    public ParameterMustHaveUniqueOrderAnalyzer()
+        : base(
+            "Parameters must have unique order",
+            "This parameter's order must be unique within the command. " +
+            "Specified order: {0}. " +
+            "Property bound to another parameter with the same order: `{1}`.")
     {
-        public ParameterMustHaveUniqueOrderAnalyzer()
-            : base(
-                "Parameters must have unique order",
-                "This parameter's order must be unique within the command.")
+    }
+
+    private void Analyze(
+        SyntaxNodeAnalysisContext context,
+        PropertyDeclarationSyntax propertyDeclaration,
+        IPropertySymbol property)
+    {
+        if (property.ContainingType is null)
+            return;
+
+        var parameter = CommandParameterSymbol.TryResolve(property);
+        if (parameter is null)
+            return;
+
+        var otherProperties = property
+            .ContainingType
+            .GetMembers()
+            .OfType<IPropertySymbol>()
+            .Where(m => !m.Equals(property, SymbolEqualityComparer.Default))
+            .ToArray();
+
+        foreach (var otherProperty in otherProperties)
         {
-        }
+            var otherParameter = CommandParameterSymbol.TryResolve(otherProperty);
+            if (otherParameter is null)
+                continue;
 
-        private void Analyze(
-            SyntaxNodeAnalysisContext context,
-            PropertyDeclarationSyntax propertyDeclaration,
-            IPropertySymbol property)
-        {
-            if (property.ContainingType is null)
-                return;
-
-            var parameter = CommandParameterSymbol.TryResolve(property);
-            if (parameter is null)
-                return;
-
-            var otherProperties = property
-                .ContainingType
-                .GetMembers()
-                .OfType<IPropertySymbol>()
-                .Where(m => !m.Equals(property, SymbolEqualityComparer.Default))
-                .ToArray();
-
-            foreach (var otherProperty in otherProperties)
+            if (parameter.Order == otherParameter.Order)
             {
-                var otherParameter = CommandParameterSymbol.TryResolve(otherProperty);
-                if (otherParameter is null)
-                    continue;
-
-                if (parameter.Order == otherParameter.Order)
-                {
-                    context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
-                }
+                context.ReportDiagnostic(
+                    CreateDiagnostic(
+                        propertyDeclaration.Identifier.GetLocation(),
+                        parameter.Order,
+                        otherProperty.Name
+                    )
+                );
             }
         }
+    }
 
-        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,58 @@ 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
 {
-    [DiagnosticAnalyzer(LanguageNames.CSharp)]
-    public class ParameterMustHaveValidConverterAnalyzer : AnalyzerBase
+    public ParameterMustHaveValidConverterAnalyzer()
+        : base(
+            $"Parameter converters must derive from `{SymbolNames.CliFxBindingConverterClass}`",
+            $"Converter specified for this parameter must derive from a compatible `{SymbolNames.CliFxBindingConverterClass}`.")
     {
-        public ParameterMustHaveValidConverterAnalyzer()
-            : base(
-                $"Parameter converters must derive from `{SymbolNames.CliFxBindingConverterClass}`",
-                $"Converter specified for this parameter must derive from `{SymbolNames.CliFxBindingConverterClass}`.")
+    }
+
+    private void Analyze(
+        SyntaxNodeAnalysisContext context,
+        PropertyDeclarationSyntax propertyDeclaration,
+        IPropertySymbol property)
+    {
+        var parameter = CommandParameterSymbol.TryResolve(property);
+        if (parameter is null)
+            return;
+
+        if (parameter.ConverterType is null)
+            return;
+
+        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)
         {
-        }
-
-        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);
+            context.ReportDiagnostic(
+                CreateDiagnostic(propertyDeclaration.Identifier.GetLocation())
+            );
         }
     }
+
+    public override void Initialize(AnalysisContext context)
+    {
+        base.Initialize(context);
+        context.HandlePropertyDeclaration(Analyze);
+    }
 }

CliFx.Analyzers/ParameterMustHaveValidValidatorsAnalyzer.cs

@@ -5,48 +5,55 @@ 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
 {
-    [DiagnosticAnalyzer(LanguageNames.CSharp)]
-    public class ParameterMustHaveValidValidatorsAnalyzer : AnalyzerBase
+    public ParameterMustHaveValidValidatorsAnalyzer()
+        : base(
+            $"Parameter validators must derive from `{SymbolNames.CliFxBindingValidatorClass}`",
+            $"Each validator specified for this parameter must derive from a compatible `{SymbolNames.CliFxBindingValidatorClass}`.")
     {
-        public ParameterMustHaveValidValidatorsAnalyzer()
-            : base(
-                $"Parameter validators must derive from `{SymbolNames.CliFxBindingValidatorClass}`",
-                $"All validators specified for this parameter must derive from `{SymbolNames.CliFxBindingValidatorClass}`.")
-        {
-        }
+    }
 
-        private void Analyze(
-            SyntaxNodeAnalysisContext context,
-            PropertyDeclarationSyntax propertyDeclaration,
-            IPropertySymbol property)
-        {
-            var parameter = CommandParameterSymbol.TryResolve(property);
-            if (parameter is null)
-                return;
+    private void Analyze(
+        SyntaxNodeAnalysisContext context,
+        PropertyDeclarationSyntax propertyDeclaration,
+        IPropertySymbol property)
+    {
+        var parameter = CommandParameterSymbol.TryResolve(property);
+        if (parameter is null)
+            return;
 
-            foreach (var validatorType in parameter.ValidatorTypes)
+        foreach (var validatorType in parameter.ValidatorTypes)
+        {
+            var validatorValueType = validatorType
+                .GetBaseTypes()
+                .FirstOrDefault(t => t.ConstructedFrom.DisplayNameMatches(SymbolNames.CliFxBindingValidatorClass))?
+                .TypeArguments
+                .FirstOrDefault();
+
+            // Value passed to the validator must be assignable from the property type
+            var isCompatible =
+                validatorValueType is not null &&
+                context.Compilation.IsAssignable(property.Type, validatorValueType);
+
+            if (!isCompatible)
             {
-                // We check against an internal interface because checking against a generic class is a pain
-                var validatorImplementsInterface = validatorType
-                    .AllInterfaces
-                    .Any(s => s.DisplayNameMatches(SymbolNames.CliFxBindingValidatorInterface));
+                context.ReportDiagnostic(
+                    CreateDiagnostic(propertyDeclaration.Identifier.GetLocation())
+                );
 
-                if (!validatorImplementsInterface)
-                {
-                    context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
-
-                    // No need to report multiple identical diagnostics on the same node
-                    break;
-                }
+                // 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,73 +6,74 @@ 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
 {
-    [DiagnosticAnalyzer(LanguageNames.CSharp)]
-    public class SystemConsoleShouldBeAvoidedAnalyzer : AnalyzerBase
+    public SystemConsoleShouldBeAvoidedAnalyzer()
+        : base(
+            $"Avoid calling `System.Console` where `{SymbolNames.CliFxConsoleInterface}` is available",
+            $"Use the provided `{SymbolNames.CliFxConsoleInterface}` abstraction instead of `System.Console` to ensure that the command can be tested in isolation.",
+            DiagnosticSeverity.Warning)
     {
-        public SystemConsoleShouldBeAvoidedAnalyzer()
-            : base(
-                $"Avoid calling `System.Console` where `{SymbolNames.CliFxConsoleInterface}` is available",
-                $"Use the provided `{SymbolNames.CliFxConsoleInterface}` abstraction instead of `System.Console` to ensure that the command can be tested in isolation.",
-                DiagnosticSeverity.Warning)
-        {
-        }
+    }
 
-        private MemberAccessExpressionSyntax? TryGetSystemConsoleMemberAccess(
-            SyntaxNodeAnalysisContext context,
-            SyntaxNode node)
-        {
-            var currentNode = node;
+    private MemberAccessExpressionSyntax? TryGetSystemConsoleMemberAccess(
+        SyntaxNodeAnalysisContext context,
+        SyntaxNode node)
+    {
+        var currentNode = node;
 
-            while (currentNode is MemberAccessExpressionSyntax memberAccess)
+        while (currentNode is MemberAccessExpressionSyntax memberAccess)
+        {
+            var member = context.SemanticModel.GetSymbolInfo(memberAccess).Symbol;
+
+            if (member?.ContainingType?.DisplayNameMatches("System.Console") == true)
             {
-                var member = context.SemanticModel.GetSymbolInfo(memberAccess).Symbol;
-
-                if (member?.ContainingType?.DisplayNameMatches("System.Console") == true)
-                {
-                    return memberAccess;
-                }
-
-                // Get inner expression, which may be another member access expression.
-                // Example: System.Console.Error
-                //          ~~~~~~~~~~~~~~          <- inner member access expression
-                //          --------------------    <- outer member access expression
-                currentNode = memberAccess.Expression;
+                return memberAccess;
             }
 
-            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,
-            // 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);
+            context.ReportDiagnostic(
+                CreateDiagnostic(systemConsoleMemberAccess.GetLocation())
+            );
         }
     }
+
+    public override void Initialize(AnalysisContext context)
+    {
+        base.Initialize(context);
+        context.RegisterSyntaxNodeAction(Analyze, SyntaxKind.SimpleMemberAccessExpression);
+    }
 }

CliFx.Analyzers/Utils/Extensions/RoslynExtensions.cs

@@ -1,53 +1,73 @@
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 
-namespace CliFx.Analyzers.Utils.Extensions
+namespace CliFx.Analyzers.Utils.Extensions;
+
+internal static class RoslynExtensions
 {
-    internal static class RoslynExtensions
+    public static bool DisplayNameMatches(this ISymbol symbol, string name) =>
+        string.Equals(
+            // Fully qualified name, without `global::`
+            symbol.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat),
+            name,
+            StringComparison.Ordinal
+        );
+
+    public static IEnumerable<INamedTypeSymbol> GetBaseTypes(this ITypeSymbol type)
     {
-        public static bool DisplayNameMatches(this ISymbol symbol, string name) =>
-            string.Equals(
-                // Fully qualified name, without `global::`
-                symbol.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat),
-                name,
-                StringComparison.Ordinal
-            );
+        var current = type.BaseType;
 
-        public static void HandleClassDeclaration(
-            this AnalysisContext analysisContext,
-            Action<SyntaxNodeAnalysisContext, ClassDeclarationSyntax, ITypeSymbol> analyze)
+        while (current is not null)
         {
-            analysisContext.RegisterSyntaxNodeAction(ctx =>
-            {
-                if (ctx.Node is not ClassDeclarationSyntax classDeclaration)
-                    return;
-
-                var type = ctx.SemanticModel.GetDeclaredSymbol(classDeclaration);
-                if (type is null)
-                    return;
-
-                analyze(ctx, classDeclaration, type);
-            }, SyntaxKind.ClassDeclaration);
-        }
-
-        public static void HandlePropertyDeclaration(
-            this AnalysisContext analysisContext,
-            Action<SyntaxNodeAnalysisContext, PropertyDeclarationSyntax, IPropertySymbol> analyze)
-        {
-            analysisContext.RegisterSyntaxNodeAction(ctx =>
-            {
-                if (ctx.Node is not PropertyDeclarationSyntax propertyDeclaration)
-                    return;
-
-                var property = ctx.SemanticModel.GetDeclaredSymbol(propertyDeclaration);
-                if (property is null)
-                    return;
-
-                analyze(ctx, propertyDeclaration, property);
-            }, SyntaxKind.PropertyDeclaration);
+            yield return current;
+            current = current.BaseType;
         }
     }
+
+    public static ITypeSymbol? TryGetEnumerableUnderlyingType(this ITypeSymbol type) => type
+        .AllInterfaces
+        .FirstOrDefault(i => i.ConstructedFrom.SpecialType == SpecialType.System_Collections_Generic_IEnumerable_T)?
+        .TypeArguments[0];
+
+    public static bool IsAssignable(this Compilation compilation, ITypeSymbol source, ITypeSymbol destination) =>
+        compilation.ClassifyConversion(source, destination).Exists;
+
+    public static void HandleClassDeclaration(
+        this AnalysisContext analysisContext,
+        Action<SyntaxNodeAnalysisContext, ClassDeclarationSyntax, ITypeSymbol> analyze)
+    {
+        analysisContext.RegisterSyntaxNodeAction(ctx =>
+        {
+            if (ctx.Node is not ClassDeclarationSyntax classDeclaration)
+                return;
+
+            var type = ctx.SemanticModel.GetDeclaredSymbol(classDeclaration);
+            if (type is null)
+                return;
+
+            analyze(ctx, classDeclaration, type);
+        }, SyntaxKind.ClassDeclaration);
+    }
+
+    public static void HandlePropertyDeclaration(
+        this AnalysisContext analysisContext,
+        Action<SyntaxNodeAnalysisContext, PropertyDeclarationSyntax, IPropertySymbol> analyze)
+    {
+        analysisContext.RegisterSyntaxNodeAction(ctx =>
+        {
+            if (ctx.Node is not PropertyDeclarationSyntax propertyDeclaration)
+                return;
+
+            var property = ctx.SemanticModel.GetDeclaredSymbol(propertyDeclaration);
+            if (property is null)
+                return;
+
+            analyze(ctx, propertyDeclaration, property);
+        }, SyntaxKind.PropertyDeclaration);
+    }
 }

CliFx.Analyzers/Utils/Extensions/StringExtensions.cs

@@ -1,18 +1,17 @@
 using System;
 
-namespace CliFx.Analyzers.Utils.Extensions
-{
-    internal static class StringExtensions
-    {
-        public static string TrimEnd(
-            this string str,
-            string sub,
-            StringComparison comparison = StringComparison.Ordinal)
-        {
-            while (str.EndsWith(sub, comparison))
-                str = str.Substring(0, str.Length - sub.Length);
+namespace CliFx.Analyzers.Utils.Extensions;
 
-            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.Substring(0, str.Length - 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]
-        public class CliFxCommand : ICommand
-        {
-            [CommandOption("str", 's')]
-            public string? StrOption { get; set; }
+        [CommandOption("str", 's')]
+        public string? StrOption { get; set; }
 
-            [CommandOption("int", 'i')]
-            public int IntOption { get; set; }
+        [CommandOption("int", 'i')]
+        public int IntOption { get; set; }
 
-            [CommandOption("bool", 'b')]
-            public bool BoolOption { get; set; }
+        [CommandOption("bool", 'b')]
+        public bool BoolOption { get; set; }
 
-            public ValueTask ExecuteAsync(IConsole console) => default;
-        }
-
-        [Benchmark(Description = "CliFx", Baseline = true)]
-        public async ValueTask<int> ExecuteWithCliFx() =>
-            await new CliApplicationBuilder()
-                .AddCommand<CliFxCommand>()
-                .Build()
-                .RunAsync(Arguments, new Dictionary<string, string>());
+        public ValueTask ExecuteAsync(IConsole console) => default;
     }
+
+    [Benchmark(Description = "CliFx", Baseline = true)]
+    public async ValueTask<int> ExecuteWithCliFx() =>
+        await new CliApplicationBuilder()
+            .AddCommand<CliFxCommand>()
+            .Build()
+            .RunAsync(Arguments, new Dictionary<string, string>());
 }

CliFx.Benchmarks/Benchmarks.Clipr.cs

@@ -1,27 +1,26 @@
 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('i', "int")]
+        public int IntOption { get; set; }
+
+        [NamedArgument('b', "bool", Constraint = NumArgsConstraint.Optional, Const = true)]
+        public bool BoolOption { get; set; }
+
+        public void Execute()
         {
-            [NamedArgument('s', "str")]
-            public string? StrOption { get; set; }
-
-            [NamedArgument('i', "int")]
-            public int IntOption { get; set; }
-
-            [NamedArgument('b', "bool", Constraint = NumArgsConstraint.Optional, Const = true)]
-            public bool BoolOption { get; set; }
-
-            public void Execute()
-            {
-            }
         }
-
-        [Benchmark(Description = "Clipr")]
-        public void ExecuteWithClipr() => CliParser.Parse<CliprCommand>(Arguments).Execute();
     }
+
+    [Benchmark(Description = "Clipr")]
+    public void ExecuteWithClipr() => CliParser.Parse<CliprCommand>(Arguments).Execute();
 }

CliFx.Benchmarks/Benchmarks.Cocona.cs

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

CliFx.Benchmarks/Benchmarks.CommandLineParser.cs

@@ -1,30 +1,29 @@
 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('i', "int")]
+        public int IntOption { get; set; }
+
+        [Option('b', "bool")]
+        public bool BoolOption { get; set; }
+
+        public void Execute()
         {
-            [Option('s', "str")]
-            public string? StrOption { get; set; }
-
-            [Option('i', "int")]
-            public int IntOption { get; set; }
-
-            [Option('b', "bool")]
-            public bool BoolOption { get; set; }
-
-            public void Execute()
-            {
-            }
         }
-
-        [Benchmark(Description = "CommandLineParser")]
-        public void ExecuteWithCommandLineParser() =>
-            new Parser()
-                .ParseArguments(Arguments, typeof(CommandLineParserCommand))
-                .WithParsed<CommandLineParserCommand>(c => c.Execute());
     }
+
+    [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")]
-            public int IntOption { get; set; }
+        [Option("--int|-i")]
+        public int IntOption { get; set; }
 
-            [Option("--bool|-b")]
-            public bool BoolOption { get; set; }
+        [Option("--bool|-b")]
+        public bool BoolOption { get; set; }
 
-            public int OnExecute() => 0;
-        }
-
-        [Benchmark(Description = "McMaster.Extensions.CommandLineUtils")]
-        public int ExecuteWithMcMaster() => CommandLineApplication.Execute<McMasterCommand>(Arguments);
+        public int OnExecute() => 0;
     }
+
+    [Benchmark(Description = "McMaster.Extensions.CommandLineUtils")]
+    public int ExecuteWithMcMaster() => CommandLineApplication.Execute<McMasterCommand>(Arguments);
 }

CliFx.Benchmarks/Benchmarks.PowerArgs.cs

@@ -1,27 +1,26 @@
 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("--int"), ArgShortcut("-i")]
+        public int IntOption { get; set; }
+
+        [ArgShortcut("--bool"), ArgShortcut("-b")]
+        public bool BoolOption { get; set; }
+
+        public void Main()
         {
-            [ArgShortcut("--str"), ArgShortcut("-s")]
-            public string? StrOption { get; set; }
-
-            [ArgShortcut("--int"), ArgShortcut("-i")]
-            public int IntOption { get; set; }
-
-            [ArgShortcut("--bool"), ArgShortcut("-b")]
-            public bool BoolOption { get; set; }
-
-            public void Main()
-            {
-            }
         }
-
-        [Benchmark(Description = "PowerArgs")]
-        public void ExecuteWithPowerArgs() => Args.InvokeMain<PowerArgsCommand>(Arguments);
     }
+
+    [Benchmark(Description = "PowerArgs")]
+    public void ExecuteWithPowerArgs() => Args.InvokeMain<PowerArgsCommand>(Arguments);
 }

CliFx.Benchmarks/Benchmarks.SystemCommandLine.cs

@@ -3,42 +3,41 @@ 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 int ExecuteHandler(string s, int i, bool b) => 0;
+
+        public Task<int> ExecuteAsync(string[] args)
         {
-            public static int ExecuteHandler(string s, int i, bool b) => 0;
-
-            public Task<int> ExecuteAsync(string[] args)
+            var command = new RootCommand
             {
-                var command = new RootCommand
+                new Option(new[] {"--str", "-s"})
                 {
-                    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>()
-                    }
-                };
+                    Argument = new Argument<string?>()
+                },
+                new Option(new[] {"--int", "-i"})
+                {
+                    Argument = new Argument<int>()
+                },
+                new Option(new[] {"--bool", "-b"})
+                {
+                    Argument = new Argument<bool>()
+                }
+            };
 
-                command.Handler = CommandHandler.Create(
-                    typeof(SystemCommandLineCommand).GetMethod(nameof(ExecuteHandler))!
-                );
+            command.Handler = CommandHandler.Create(
+                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,17 @@ using BenchmarkDotNet.Configs;
 using BenchmarkDotNet.Order;
 using BenchmarkDotNet.Running;
 
-namespace CliFx.Benchmarks
-{
-    [RankColumn]
-    [Orderer(SummaryOrderPolicy.FastestToSlowest)]
-    public partial class Benchmarks
-    {
-        private static readonly string[] Arguments = {"--str", "hello world", "-i", "13", "-b"};
+namespace CliFx.Benchmarks;
 
-        public static void Main() => BenchmarkRunner.Run<Benchmarks>(
-            DefaultConfig
-                .Instance
-                .With(ConfigOptions.DisableOptimizationsValidator)
-        );
-    }
+[RankColumn]
+[Orderer(SummaryOrderPolicy.FastestToSlowest)]
+public partial class Benchmarks
+{
+    private static readonly string[] Arguments = {"--str", "hello world", "-i", "13", "-b"};
+
+    public static void Main() => BenchmarkRunner.Run<Benchmarks>(
+        DefaultConfig
+            .Instance
+            .WithOptions(ConfigOptions.DisableOptimizationsValidator)
+    );
 }

CliFx.Benchmarks/CliFx.Benchmarks.csproj

@@ -2,16 +2,16 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net5.0</TargetFramework>
+    <TargetFramework>net7.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="BenchmarkDotNet" Version="0.12.0" />
+    <PackageReference Include="BenchmarkDotNet" Version="0.13.2" />
     <PackageReference Include="clipr" Version="1.6.1" />
-    <PackageReference Include="Cocona" Version="1.5.0" />
-    <PackageReference Include="CommandLineParser" Version="2.8.0" />
-    <PackageReference Include="McMaster.Extensions.CommandLineUtils" Version="3.1.0" />
-    <PackageReference Include="PowerArgs" Version="3.6.0" />
+    <PackageReference Include="Cocona" Version="2.1.0" />
+    <PackageReference Include="CommandLineParser" Version="2.9.1" />
+    <PackageReference Include="McMaster.Extensions.CommandLineUtils" Version="4.0.2" />
+    <PackageReference Include="PowerArgs" Version="4.0.0" />
     <PackageReference Include="System.CommandLine" Version="2.0.0-beta1.20574.7" />
   </ItemGroup>
 

CliFx.Demo/CliFx.Demo.csproj

@@ -2,17 +2,17 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net5.0</TargetFramework>
+    <TargetFramework>net7.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="5.0.1" />
-    <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="7.0.0" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.2" />
   </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,64 @@ using CliFx.Demo.Utils;
 using CliFx.Exceptions;
 using CliFx.Infrastructure;
 
-namespace CliFx.Demo.Commands
+namespace CliFx.Demo.Commands;
+
+[Command("book add", Description = "Add a book to the library.")]
+public partial class BookAddCommand : ICommand
 {
-    [Command("book add", Description = "Add a book to the library.")]
-    public partial class BookAddCommand : ICommand
+    private readonly LibraryProvider _libraryProvider;
+
+    [CommandParameter(0, Name = "title", Description = "Book title.")]
+    public required string Title { get; init; }
+
+    [CommandOption("author", 'a', IsRequired = true, Description = "Book author.")]
+    public required string Author { get; init; }
+
+    [CommandOption("published", 'p', Description = "Book publish date.")]
+    public DateTimeOffset Published { get; init; } = CreateRandomDate();
+
+    [CommandOption("isbn", 'n', Description = "Book ISBN.")]
+    public Isbn Isbn { get; init; } = CreateRandomIsbn();
+
+    public BookAddCommand(LibraryProvider libraryProvider)
     {
-        private readonly LibraryProvider _libraryProvider;
-
-        [CommandParameter(0, Name = "title", Description = "Book title.")]
-        public string Title { get; init; } = "";
-
-        [CommandOption("author", 'a', IsRequired = true, Description = "Book author.")]
-        public string Author { get; init; } = "";
-
-        [CommandOption("published", 'p', Description = "Book publish date.")]
-        public DateTimeOffset Published { get; init; } = CreateRandomDate();
-
-        [CommandOption("isbn", 'n', Description = "Book ISBN.")]
-        public Isbn Isbn { get; init; } = CreateRandomIsbn();
-
-        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;
-        }
+        _libraryProvider = libraryProvider;
     }
 
-    public partial class BookAddCommand
+    public ValueTask ExecuteAsync(IConsole console)
     {
-        private static readonly Random Random = new();
+        if (_libraryProvider.TryGetBook(Title) is not null)
+            throw new CommandException("Book already exists.", 10);
 
-        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
-        );
+        var book = new Book(Title, Author, Published, Isbn);
+        _libraryProvider.AddBook(book);
 
-        private static Isbn CreateRandomIsbn() => new(
-            Random.Next(0, 999),
-            Random.Next(0, 99),
-            Random.Next(0, 99999),
-            Random.Next(0, 99),
-            Random.Next(0, 9)
-        );
+        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(
+        Random.Next(0, 999),
+        Random.Next(0, 99),
+        Random.Next(0, 99999),
+        Random.Next(0, 99),
+        Random.Next(0, 9)
+    );
+}

CliFx.Demo/Commands/BookCommand.cs

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

CliFx.Demo/Commands/BookListCommand.cs

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

CliFx.Demo/Commands/BookRemoveCommand.cs

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

CliFx.Demo/Domain/Book.cs

@@ -1,23 +1,22 @@
 using System;
 
-namespace CliFx.Demo.Domain
+namespace CliFx.Demo.Domain;
+
+public class Book
 {
-    public class Book
+    public string Title { get; }
+
+    public string Author { get; }
+
+    public DateTimeOffset Published { get; }
+
+    public Isbn Isbn { get; }
+
+    public Book(string title, string author, DateTimeOffset published, Isbn isbn)
     {
-        public string Title { get; }
-
-        public string Author { get; }
-
-        public DateTimeOffset Published { get; }
-
-        public Isbn Isbn { get; }
-
-        public Book(string title, string author, DateTimeOffset published, Isbn isbn)
-        {
-            Title = title;
-            Author = author;
-            Published = published;
-            Isbn = isbn;
-        }
+        Title = title;
+        Author = author;
+        Published = published;
+        Isbn = isbn;
     }
 }

CliFx.Demo/Domain/Isbn.cs

@@ -1,45 +1,44 @@
 using System;
 
-namespace CliFx.Demo.Domain
+namespace CliFx.Demo.Domain;
+
+public partial class Isbn
 {
-    public partial class Isbn
+    public int EanPrefix { get; }
+
+    public int RegistrationGroup { get; }
+
+    public int Registrant { get; }
+
+    public int Publication { get; }
+
+    public int CheckDigit { get; }
+
+    public Isbn(int eanPrefix, int registrationGroup, int registrant, int publication, int checkDigit)
     {
-        public int EanPrefix { get; }
-
-        public int RegistrationGroup { get; }
-
-        public int Registrant { get; }
-
-        public int Publication { get; }
-
-        public int CheckDigit { get; }
-
-        public Isbn(int eanPrefix, int registrationGroup, int registrant, int publication, int checkDigit)
-        {
-            EanPrefix = eanPrefix;
-            RegistrationGroup = registrationGroup;
-            Registrant = registrant;
-            Publication = publication;
-            CheckDigit = checkDigit;
-        }
-
-        public override string ToString() =>
-            $"{EanPrefix:000}-{RegistrationGroup:00}-{Registrant:00000}-{Publication:00}-{CheckDigit:0}";
+        EanPrefix = eanPrefix;
+        RegistrationGroup = registrationGroup;
+        Registrant = registrant;
+        Publication = publication;
+        CheckDigit = checkDigit;
     }
 
-    public partial class Isbn
-    {
-        public static Isbn Parse(string value, IFormatProvider formatProvider)
-        {
-            var components = value.Split('-', 5, StringSplitOptions.RemoveEmptyEntries);
+    public override string ToString() =>
+        $"{EanPrefix:000}-{RegistrationGroup:00}-{Registrant:00000}-{Publication:00}-{CheckDigit:0}";
+}
 
-            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)
-            );
-        }
+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,34 @@
 using System.Collections.Generic;
 using System.Linq;
 
-namespace CliFx.Demo.Domain
+namespace CliFx.Demo.Domain;
+
+public partial class Library
 {
-    public partial class Library
+    public IReadOnlyList<Book> Books { get; }
+
+    public Library(IReadOnlyList<Book> books)
     {
-        public IReadOnlyList<Book> Books { get; }
-
-        public Library(IReadOnlyList<Book> books)
-        {
-            Books = books;
-        }
-
-        public Library WithBook(Book book)
-        {
-            var books = Books.ToList();
-            books.Add(book);
-
-            return new Library(books);
-        }
-
-        public Library WithoutBook(Book book)
-        {
-            var books = Books.Where(b => b != book).ToArray();
-
-            return new Library(books);
-        }
+        Books = books;
     }
 
-    public partial class Library
+    public Library WithBook(Book book)
     {
-        public static Library Empty { get; } = new(Array.Empty<Book>());
+        var books = Books.ToList();
+        books.Add(book);
+
+        return new Library(books);
+    }
+
+    public Library WithoutBook(Book book)
+    {
+        var books = Books.Where(b => b != book).ToArray();
+
+        return new Library(books);
     }
 }
+
+public partial class Library
+{
+    public static Library Empty { get; } = new(Array.Empty<Book>());
+}

CliFx.Demo/Domain/LibraryProvider.cs

@@ -2,40 +2,39 @@
 using System.Linq;
 using Newtonsoft.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 = JsonConvert.SerializeObject(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;
 
-        public Library GetLibrary()
-        {
-            if (!File.Exists(StorageFilePath))
-                return Library.Empty;
+        var data = File.ReadAllText(StorageFilePath);
 
-            var data = File.ReadAllText(StorageFilePath);
+        return JsonConvert.DeserializeObject<Library>(data) ?? Library.Empty;
+    }
 
-            return JsonConvert.DeserializeObject<Library>(data);
-        }
+    public Book? TryGetBook(string title) => GetLibrary().Books.FirstOrDefault(b => b.Title == title);
 
-        public Book? TryGetBook(string title) => GetLibrary().Books.FirstOrDefault(b => b.Title == title);
+    public void AddBook(Book book)
+    {
+        var updatedLibrary = GetLibrary().WithBook(book);
+        StoreLibrary(updatedLibrary);
+    }
 
-        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 void RemoveBook(Book book)
+    {
+        var updatedLibrary = GetLibrary().WithoutBook(book);
+        StoreLibrary(updatedLibrary);
     }
 }

CliFx.Demo/Program.cs

@@ -1,36 +1,25 @@
-using System;
-using System.Threading.Tasks;
+using CliFx;
 using CliFx.Demo.Commands;
 using CliFx.Demo.Domain;
 using Microsoft.Extensions.DependencyInjection;
 
-namespace CliFx.Demo
-{
-    public static class Program
-    {
-        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
+var services = new ServiceCollection();
 
-            // Register services
-            services.AddSingleton<LibraryProvider>();
+// Register services
+services.AddSingleton<LibraryProvider>();
 
-            // Register commands
-            services.AddTransient<BookCommand>();
-            services.AddTransient<BookAddCommand>();
-            services.AddTransient<BookRemoveCommand>();
-            services.AddTransient<BookListCommand>();
+// Register commands
+services.AddTransient<BookCommand>();
+services.AddTransient<BookAddCommand>();
+services.AddTransient<BookRemoveCommand>();
+services.AddTransient<BookListCommand>();
 
-            return services.BuildServiceProvider();
-        }
+var serviceProvider = services.BuildServiceProvider();
 
-        public static async Task<int> Main() =>
-            await new CliApplicationBuilder()
-                .SetDescription("Demo application showcasing CliFx features.")
-                .AddCommandsFromThisAssembly()
-                .UseTypeActivator(GetServiceProvider().GetRequiredService)
-                .Build()
-                .RunAsync();
-    }
-}
+return await new CliApplicationBuilder()
+    .SetDescription("Demo application showcasing CliFx features.")
+    .AddCommandsFromThisAssembly()
+    .UseTypeActivator(serviceProvider.GetRequiredService)
+    .Build()
+    .RunAsync();

CliFx.Demo/Readme.md

@@ -2,4 +2,4 @@
 
 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,35 @@
 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))
-                writer.WriteLine(book.Title);
+        // Title
+        using (writer.Console.WithForegroundColor(ConsoleColor.White))
+            writer.WriteLine(book.Title);
 
-            // Author
-            writer.Write("  ");
-            writer.Write("Author: ");
+        // Author
+        writer.Write("  ");
+        writer.Write("Author: ");
 
-            using (writer.Console.WithForegroundColor(ConsoleColor.White))
-                writer.WriteLine(book.Author);
+        using (writer.Console.WithForegroundColor(ConsoleColor.White))
+            writer.WriteLine(book.Author);
 
-            // Published
-            writer.Write("  ");
-            writer.Write("Published: ");
+        // Published
+        writer.Write("  ");
+        writer.Write("Published: ");
 
-            using (writer.Console.WithForegroundColor(ConsoleColor.White))
-                writer.WriteLine($"{book.Published:d}");
+        using (writer.Console.WithForegroundColor(ConsoleColor.White))
+            writer.WriteLine($"{book.Published:d}");
 
-            // ISBN
-            writer.Write("  ");
-            writer.Write("ISBN: ");
+        // ISBN
+        writer.Write("  ");
+        writer.Write("ISBN: ");
 
-            using (writer.Console.WithForegroundColor(ConsoleColor.White))
-                writer.WriteLine(book.Isbn);
-        }
+        using (writer.Console.WithForegroundColor(ConsoleColor.White))
+            writer.WriteLine(book.Isbn);
     }
 }

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

@@ -2,12 +2,12 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net5.0</TargetFramework>
+    <TargetFramework>net7.0</TargetFramework>
   </PropertyGroup>
 
   <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/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 class ConsoleTestCommand : ICommand
+    public ValueTask ExecuteAsync(IConsole console)
     {
-        public ValueTask ExecuteAsync(IConsole console)
+        var input = console.Input.ReadToEnd();
+
+        using (console.WithColors(ConsoleColor.Black, ConsoleColor.White))
         {
-            var input = console.Input.ReadToEnd();
-
-            using (console.WithColors(ConsoleColor.Black, ConsoleColor.White))
-            {
-                console.Output.WriteLine(input);
-                console.Error.WriteLine(input);
-            }
-
-            return default;
+            console.Output.WriteLine(input);
+            console.Error.WriteLine(input);
         }
+
+        return default;
     }
 }

CliFx.Tests.Dummy/Commands/EnvironmentTestCommand.cs

@@ -2,19 +2,18 @@
 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")]
-    public class EnvironmentTestCommand : ICommand
+    [CommandOption("target", EnvironmentVariable = "ENV_TARGET")]
+    public string GreetingTarget { get; set; } = "World";
+
+    public ValueTask ExecuteAsync(IConsole console)
     {
-        [CommandOption("target", EnvironmentVariable = "ENV_TARGET")]
-        public string GreetingTarget { get; set; } = "World";
+        console.Output.WriteLine($"Hello {GreetingTarget}!");
 
-        public ValueTask ExecuteAsync(IConsole console)
-        {
-            console.Output.WriteLine($"Hello {GreetingTarget}!");
-
-            return default;
-        }
+        return default;
     }
 }

CliFx.Tests.Dummy/Program.cs

@@ -1,24 +1,31 @@
-using System.Reflection;
+using System;
+using System.Reflection;
 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 partial class Program
 {
-    // This dummy application is used in tests for scenarios
-    // that require an external process to properly verify.
+    public static Assembly Assembly { get; } = typeof(Program).Assembly;
 
-    public static partial class Program
+    public static string Location { get; } = Assembly.Location;
+}
+
+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;
-    }
-
-    public static partial class Program
-    {
-        public static async Task Main() =>
-            await new CliApplicationBuilder()
-                .AddCommandsFromThisAssembly()
-                .Build()
-                .RunAsync();
+        await new CliApplicationBuilder()
+            .AddCommandsFromThisAssembly()
+            .Build()
+            .RunAsync();
     }
 }

CliFx.Tests/ApplicationSpecs.cs

@@ -6,81 +6,80 @@ using FluentAssertions;
 using Xunit;
 using Xunit.Abstractions;
 
-namespace CliFx.Tests
+namespace CliFx.Tests;
+
+public class ApplicationSpecs : SpecsBase
 {
-    public class ApplicationSpecs : SpecsBase
+    public ApplicationSpecs(ITestOutputHelper testOutput)
+        : base(testOutput)
     {
-        public ApplicationSpecs(ITestOutputHelper testOutput)
-            : base(testOutput)
-        {
-        }
+    }
 
-        [Fact]
-        public async Task Application_can_be_created_with_minimal_configuration()
-        {
-            // Act
-            var app = new CliApplicationBuilder()
-                .AddCommandsFromThisAssembly()
-                .UseConsole(FakeConsole)
-                .Build();
+    [Fact]
+    public async Task Application_can_be_created_with_minimal_configuration()
+    {
+        // Act
+        var app = new CliApplicationBuilder()
+            .AddCommandsFromThisAssembly()
+            .UseConsole(FakeConsole)
+            .Build();
 
-            var exitCode = await app.RunAsync(
-                Array.Empty<string>(),
-                new Dictionary<string, string>()
-            );
+        var exitCode = await app.RunAsync(
+            Array.Empty<string>(),
+            new Dictionary<string, string>()
+        );
 
-            // Assert
-            exitCode.Should().Be(0);
-        }
+        // 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();
+    [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>()
-            );
+        var exitCode = await app.RunAsync(
+            Array.Empty<string>(),
+            new Dictionary<string, string>()
+        );
 
-            // Assert
-            exitCode.Should().Be(0);
-        }
+        // 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();
+    [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 exitCode = await app.RunAsync(
+            Array.Empty<string>(),
+            new Dictionary<string, string>()
+        );
 
-            var stdErr = FakeConsole.ReadErrorString();
+        var stdErr = FakeConsole.ReadErrorString();
 
-            // Assert
-            exitCode.Should().NotBe(0);
-            stdErr.Should().Contain("not a valid command");
-        }
+        // Assert
+        exitCode.Should().NotBe(0);
+        stdErr.Should().Contain("not a valid command");
     }
 }

CliFx.Tests/CancellationSpecs.cs

@@ -6,62 +6,63 @@ using FluentAssertions;
 using Xunit;
 using Xunit.Abstractions;
 
-namespace CliFx.Tests
-{
-    public class CancellationSpecs : SpecsBase
-    {
-        public CancellationSpecs(ITestOutputHelper testOutput)
-            : base(testOutput)
-        {
-        }
+namespace CliFx.Tests;
 
-        [Fact]
-        public async Task Command_can_register_to_receive_a_cancellation_signal_from_the_console()
-        {
-            // Arrange
-            var commandType = DynamicCommandBuilder.Compile(
-                // language=cs
-                @"
-[Command]
-public class Command : ICommand
+public class CancellationSpecs : SpecsBase
 {
-    public async ValueTask ExecuteAsync(IConsole console)
+    public CancellationSpecs(ITestOutputHelper testOutput)
+        : base(testOutput)
     {
-        try
-        {
-            await Task.Delay(
-                TimeSpan.FromSeconds(3),
-                console.RegisterCancellationHandler()
-            );
-
-            console.Output.WriteLine(""Completed successfully"");
-        }
-        catch (OperationCanceledException)
-        {
-            console.Output.WriteLine(""Cancelled"");
-            throw;
-        }
     }
-}");
 
-            var application = new CliApplicationBuilder()
-                .AddCommand(commandType)
-                .UseConsole(FakeConsole)
-                .Build();
+    [Fact]
+    public async Task Command_can_register_to_receive_a_cancellation_signal_from_the_console()
+    {
+        // Arrange
+        var commandType = DynamicCommandBuilder.Compile(
+            // language=cs
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                public async ValueTask ExecuteAsync(IConsole console)
+                {
+                    try
+                    {
+                        await Task.Delay(
+                            TimeSpan.FromSeconds(3),
+                            console.RegisterCancellationHandler()
+                        );
 
-            // Act
-            FakeConsole.RequestCancellation(TimeSpan.FromSeconds(0.2));
+                        console.Output.WriteLine("Completed successfully");
+                    }
+                    catch (OperationCanceledException)
+                    {
+                        console.Output.WriteLine("Cancelled");
+                        throw;
+                    }
+                }
+            }
+            """
+        );
 
-            var exitCode = await application.RunAsync(
-                Array.Empty<string>(),
-                new Dictionary<string, string>()
-            );
+        var application = new CliApplicationBuilder()
+            .AddCommand(commandType)
+            .UseConsole(FakeConsole)
+            .Build();
 
-            var stdOut = FakeConsole.ReadOutputString();
+        // Act
+        FakeConsole.RequestCancellation(TimeSpan.FromSeconds(0.2));
 
-            // Assert
-            exitCode.Should().NotBe(0);
-            stdOut.Trim().Should().Be("Cancelled");
-        }
+        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>
-    <IsPackable>false</IsPackable>
-    <IsTestProject>true</IsTestProject>
-    <CollectCoverage>true</CollectCoverage>
-    <CoverletOutputFormat>opencover</CoverletOutputFormat>
+    <TargetFramework>net7.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
@@ -13,14 +9,16 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="CliWrap" Version="3.3.1" />
-    <PackageReference Include="FluentAssertions" Version="5.10.3" />
-    <PackageReference Include="GitHubActionsTestLogger" Version="1.2.0" />
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="3.4.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.9.1" />
-    <PackageReference Include="xunit" Version="2.4.1" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3" PrivateAssets="all" />
-    <PackageReference Include="coverlet.msbuild" Version="3.0.3" PrivateAssets="all" />
+    <PackageReference Include="Basic.Reference.Assemblies.Net70" Version="1.4.1" />
+    <PackageReference Include="CliWrap" Version="3.5.0" />
+    <PackageReference Include="FluentAssertions" Version="6.8.0" />
+    <PackageReference Include="GitHubActionsTestLogger" Version="2.0.1" PrivateAssets="all" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.4.0" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="7.0.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.4.0" />
+    <PackageReference Include="xunit" Version="2.4.2" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5" PrivateAssets="all" />
+    <PackageReference Include="coverlet.collector" Version="3.2.0" PrivateAssets="all" />
   </ItemGroup>
 
   <ItemGroup>
@@ -28,12 +26,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,214 @@
 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 : SpecsBase
 {
-    public class ConsoleSpecs : SpecsBase
+    public ConsoleSpecs(ITestOutputHelper testOutput)
+        : base(testOutput)
     {
-        public ConsoleSpecs(ITestOutputHelper testOutput)
-            : base(testOutput)
-        {
-        }
-
-        [Fact]
-        public async Task Real_console_maps_directly_to_system_console()
-        {
-            // Can't verify our own console output, so using an
-            // external process for this test.
-
-            // Arrange
-            var command = "Hello world" | Cli.Wrap("dotnet")
-                .WithArguments(a => a
-                    .Add(Dummy.Program.Location)
-                    .Add("console-test"));
-
-            // Act
-            var result = await command.ExecuteBufferedAsync();
-
-            // Assert
-            result.StandardOutput.Trim().Should().Be("Hello world");
-            result.StandardError.Trim().Should().Be("Hello world");
-        }
-
-        [Fact]
-        public async Task Fake_console_does_not_leak_to_system_console()
-        {
-            // Arrange
-            var commandType = DynamicCommandBuilder.Compile(
-                // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{   
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.ResetColor();
-        console.ForegroundColor = ConsoleColor.DarkMagenta;
-        console.BackgroundColor = ConsoleColor.DarkMagenta;
-        console.CursorLeft = 42;
-        console.CursorTop = 24;
-
-        console.Output.WriteLine(""Hello "");
-        console.Error.WriteLine(""world!"");
-
-        return default;
     }
-}
-");
 
-            var application = new CliApplicationBuilder()
-                .AddCommand(commandType)
-                .UseConsole(FakeConsole)
-                .Build();
+    [Fact]
+    public async Task Real_console_maps_directly_to_system_console()
+    {
+        // Can't verify our own console output, so using an
+        // external process for this test.
 
-            // Act
-            var exitCode = await application.RunAsync(
-                Array.Empty<string>(),
-                new Dictionary<string, string>()
+        // Arrange
+        var command = "Hello world" | Cli.Wrap("dotnet")
+            .WithArguments(a => a
+                .Add(Dummy.Program.Location)
+                .Add("console-test")
             );
 
-            // Assert
-            exitCode.Should().Be(0);
+        // Act
+        var result = await command.ExecuteBufferedAsync();
 
-            Console.OpenStandardInput().Should().NotBe(FakeConsole.Input.BaseStream);
-            Console.OpenStandardOutput().Should().NotBe(FakeConsole.Output.BaseStream);
-            Console.OpenStandardError().Should().NotBe(FakeConsole.Error.BaseStream);
+        // Assert
+        result.StandardOutput.Trim().Should().Be("Hello world");
+        result.StandardError.Trim().Should().Be("Hello world");
+    }
 
-            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)
+    [Fact]
+    public async Task Fake_console_does_not_leak_to_system_console()
     {
-        var input = console.Input.ReadToEnd();
-        console.Output.WriteLine(input);
-        console.Error.WriteLine(input);
+        // Arrange
+        var commandType = DynamicCommandBuilder.Compile(
+            // language=cs
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.ResetColor();
+                    console.ForegroundColor = ConsoleColor.DarkMagenta;
+                    console.BackgroundColor = ConsoleColor.DarkMagenta;
+                    console.WindowWidth = 100;
+                    console.WindowHeight = 25;
+                    console.CursorLeft = 42;
+                    console.CursorTop = 24;
 
-        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");
-        }
+                    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 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");
+    }
+
+    [Fact]
+    public async Task Fake_console_can_read_key_presses()
+    {
+        // Arrange
+        var commandType = DynamicCommandBuilder.Compile(
+            // language=cs
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine(console.ReadKey().Key);
+                    console.Output.WriteLine(console.ReadKey().Key);
+                    console.Output.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>()
+        );
+
+        var stdOut = FakeConsole.ReadOutputString();
+
+        // Assert
+        exitCode.Should().Be(0);
+        stdOut.Trim().Should().ConsistOfLines(
+            "D0",
+            "A",
+            "Backspace"
+        );
+    }
+
+    [Fact]
+    public void Console_does_not_emit_preamble_when_used_with_encoding_that_has_it()
+    {
+        // Arrange
+        using var buffer = new MemoryStream();
+        using var consoleWriter = new ConsoleWriter(FakeConsole, buffer, Encoding.UTF8);
+
+        // Act
+        consoleWriter.Write("Hello world");
+        consoleWriter.Flush();
+
+        var output = consoleWriter.Encoding.GetString(buffer.ToArray());
+
+        // Assert
+        output.Should().Be("Hello world");
     }
 }

CliFx.Tests/DirectivesSpecs.cs

@@ -10,103 +10,104 @@ using FluentAssertions;
 using Xunit;
 using Xunit.Abstractions;
 
-namespace CliFx.Tests
+namespace CliFx.Tests;
+
+public class DirectivesSpecs : SpecsBase
 {
-    public class DirectivesSpecs : SpecsBase
+    public DirectivesSpecs(ITestOutputHelper testOutput)
+        : base(testOutput)
     {
-        public DirectivesSpecs(ITestOutputHelper testOutput)
-            : base(testOutput)
+    }
+
+    [Fact]
+    public async Task Debug_directive_can_be_specified_to_interrupt_execution_until_a_debugger_is_attached()
+    {
+        // Arrange
+        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));
 
-        [Fact]
-        public async Task Debug_directive_can_be_specified_to_interrupt_execution_until_a_debugger_is_attached()
-        {
-            // Arrange
-            var stdOutBuffer = new StringBuilder();
+            var task = command.ExecuteAsync(cts.Token);
 
-            var command = Cli.Wrap("dotnet")
-                .WithArguments(a => a
-                    .Add(Dummy.Program.Location)
-                    .Add("[debug]")) | stdOutBuffer;
-
-            // Act
-            try
+            // 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)
             {
-                // 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)
                 {
-                    if (stdOutBuffer.Length > 0)
-                    {
-                        cts.Cancel();
-                        break;
-                    }
-
-                    await Task.Delay(100, cts.Token);
+                    cts.Cancel();
+                    break;
                 }
 
-                await task;
-            }
-            catch (OperationCanceledException)
-            {
-                // It's expected to fail
+                await Task.Delay(100, cts.Token);
             }
 
-            var stdOut = stdOutBuffer.ToString();
-
-            // Assert
-            stdOut.Should().Contain("Attach debugger to");
-
-            TestOutput.WriteLine(stdOut);
+            await task;
         }
-
-        [Fact]
-        public async Task Preview_directive_can_be_specified_to_print_command_input()
+        catch (OperationCanceledException)
         {
-            // Arrange
-            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\""
-            );
+            // This is expected
         }
+
+        var stdOut = stdOutBuffer.ToString();
+
+        // Assert
+        stdOut.Should().Contain("Attach debugger to");
+
+        TestOutput.WriteLine(stdOut);
+    }
+
+    [Fact]
+    public async Task Preview_directive_can_be_specified_to_print_command_input()
+    {
+        // Arrange
+        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\""
+        );
     }
 }

CliFx.Tests/EnvironmentSpecs.cs

@@ -10,251 +10,257 @@ using FluentAssertions;
 using Xunit;
 using Xunit.Abstractions;
 
-namespace CliFx.Tests
-{
-    public class EnvironmentSpecs : SpecsBase
-    {
-        public EnvironmentSpecs(ITestOutputHelper testOutput)
-            : base(testOutput)
-        {
-        }
+namespace CliFx.Tests;
 
-        [Fact]
-        public async Task Option_can_fall_back_to_an_environment_variable()
-        {
-            // Arrange
-            var commandType = DynamicCommandBuilder.Compile(
-                // language=cs
-                @"
-[Command]
-public class Command : ICommand
+public class EnvironmentSpecs : SpecsBase
 {
-    [CommandOption(""foo"", IsRequired = true, EnvironmentVariable = ""ENV_FOO"")]
-    public string Foo { get; set; }
-    
-    public ValueTask ExecuteAsync(IConsole console)
+    public EnvironmentSpecs(ITestOutputHelper testOutput)
+        : base(testOutput)
     {
-        console.Output.WriteLine(Foo);
-        return default;
     }
-}
-");
 
-            var application = new CliApplicationBuilder()
-                .AddCommand(commandType)
-                .UseConsole(FakeConsole)
-                .Build();
+    [Fact]
+    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")]
+                public string Foo { get; set; }
 
-            // Act
-            var exitCode = await application.RunAsync(
-                Array.Empty<string>(),
-                new Dictionary<string, string>
+                public ValueTask ExecuteAsync(IConsole console)
                 {
-                    ["ENV_FOO"] = "bar"
+                    console.Output.WriteLine(Foo);
+                    return default;
                 }
-            );
+            }
+            """
+        );
 
-            var stdOut = FakeConsole.ReadOutputString();
+        var application = new CliApplicationBuilder()
+            .AddCommand(commandType)
+            .UseConsole(FakeConsole)
+            .Build();
 
-            // Assert
-            exitCode.Should().Be(0);
-            stdOut.Trim().Should().Be("bar");
-        }
+        // Act
+        var exitCode = await application.RunAsync(
+            Array.Empty<string>(),
+            new Dictionary<string, string>
+            {
+                ["ENV_FOO"] = "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; }
+        var stdOut = FakeConsole.ReadOutputString();
 
-    public ValueTask ExecuteAsync(IConsole console)
+        // 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()
     {
-        console.Output.WriteLine(Foo);
-        return default;
-    }
-}
-");
+        // Arrange
+        var commandType = DynamicCommandBuilder.Compile(
+            // language=cs
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo", EnvironmentVariable = "ENV_FOO")]
+                public string Foo { get; set; }
 
-            var application = new CliApplicationBuilder()
-                .AddCommand(commandType)
-                .UseConsole(FakeConsole)
-                .Build();
-
-            // Act
-            var exitCode = await application.RunAsync(
-                new[] {"--foo", "baz"},
-                new Dictionary<string, string>
+                public ValueTask ExecuteAsync(IConsole console)
                 {
-                    ["ENV_FOO"] = "bar"
+                    console.Output.WriteLine(Foo);
+                    return default;
                 }
-            );
+            }
+            """
+        );
 
-            var stdOut = FakeConsole.ReadOutputString();
+        var application = new CliApplicationBuilder()
+            .AddCommand(commandType)
+            .UseConsole(FakeConsole)
+            .Build();
 
-            // Assert
-            exitCode.Should().Be(0);
-            stdOut.Trim().Should().Be("baz");
-        }
+        // Act
+        var exitCode = await application.RunAsync(
+            new[] {"--foo", "baz"},
+            new Dictionary<string, string>
+            {
+                ["ENV_FOO"] = "bar"
+            }
+        );
 
-        [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; }
+        var stdOut = FakeConsole.ReadOutputString();
 
-    public ValueTask ExecuteAsync(IConsole console)
+        // 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()
     {
-        foreach (var i in Foo)
-            console.Output.WriteLine(i);
+        // Arrange
+        var commandType = DynamicCommandBuilder.Compile(
+            // language=cs
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo", EnvironmentVariable = "ENV_FOO")]
+                public IReadOnlyList<string> Foo { get; set; }
 
-        return default;
-    }
-}
-");
-
-            var application = new CliApplicationBuilder()
-                .AddCommand(commandType)
-                .UseConsole(FakeConsole)
-                .Build();
-
-            // Act
-            var exitCode = await application.RunAsync(
-                Array.Empty<string>(),
-                new Dictionary<string, string>
+                public ValueTask ExecuteAsync(IConsole console)
                 {
-                    ["ENV_FOO"] = $"bar{Path.PathSeparator}baz"
+                    foreach (var i in Foo)
+                        console.Output.WriteLine(i);
+
+                    return default;
                 }
-            );
+            }
+            """
+        );
 
-            var stdOut = FakeConsole.ReadOutputString();
+        var application = new CliApplicationBuilder()
+            .AddCommand(commandType)
+            .UseConsole(FakeConsole)
+            .Build();
 
-            // Assert
-            exitCode.Should().Be(0);
-            stdOut.Should().ConsistOfLines(
-                "bar",
-                "baz"
-            );
-        }
+        // Act
+        var exitCode = await application.RunAsync(
+            Array.Empty<string>(),
+            new Dictionary<string, string>
+            {
+                ["ENV_FOO"] = $"bar{Path.PathSeparator}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; }
+        var stdOut = FakeConsole.ReadOutputString();
 
-    public ValueTask ExecuteAsync(IConsole console)
+        // 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()
     {
-        console.Output.WriteLine(Foo);
-        return default;
-    }
-}
-");
+        // Arrange
+        var commandType = DynamicCommandBuilder.Compile(
+            // language=cs
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo", EnvironmentVariable = "ENV_FOO")]
+                public string Foo { get; set; }
 
-            var application = new CliApplicationBuilder()
-                .AddCommand(commandType)
-                .UseConsole(FakeConsole)
-                .Build();
-
-            // Act
-            var exitCode = await application.RunAsync(
-                Array.Empty<string>(),
-                new Dictionary<string, string>
+                public ValueTask ExecuteAsync(IConsole console)
                 {
-                    ["ENV_FOO"] = $"bar{Path.PathSeparator}baz"
+                    console.Output.WriteLine(Foo);
+                    return default;
                 }
-            );
+            }
+            """
+        );
 
-            var stdOut = FakeConsole.ReadOutputString();
+        var application = new CliApplicationBuilder()
+            .AddCommand(commandType)
+            .UseConsole(FakeConsole)
+            .Build();
 
-            // Assert
-            exitCode.Should().Be(0);
-            stdOut.Trim().Should().Be($"bar{Path.PathSeparator}baz");
-        }
+        // Act
+        var exitCode = await application.RunAsync(
+            Array.Empty<string>(),
+            new Dictionary<string, string>
+            {
+                ["ENV_FOO"] = $"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; }
+        var stdOut = FakeConsole.ReadOutputString();
 
-    public ValueTask ExecuteAsync(IConsole console)
+        // Assert
+        exitCode.Should().Be(0);
+        stdOut.Trim().Should().Be($"bar{Path.PathSeparator}baz");
+    }
+
+    [Fact]
+    public async Task Environment_variables_are_matched_case_sensitively()
     {
-        console.Output.WriteLine(Foo);
-        return default;
-    }
-}
-");
+        // Arrange
+        var commandType = DynamicCommandBuilder.Compile(
+            // language=cs
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo", EnvironmentVariable = "ENV_FOO")]
+                public string Foo { get; set; }
 
-            var application = new CliApplicationBuilder()
-                .AddCommand(commandType)
-                .UseConsole(FakeConsole)
-                .Build();
-
-            // Act
-            var exitCode = await application.RunAsync(
-                Array.Empty<string>(),
-                new Dictionary<string, string>
+                public ValueTask ExecuteAsync(IConsole console)
                 {
-                    ["ENV_foo"] = "baz",
-                    ["ENV_FOO"] = "bar",
-                    ["env_FOO"] = "qop"
+                    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")
             );
 
-            var stdOut = FakeConsole.ReadOutputString();
+        // Act
+        var result = await command.ExecuteBufferedAsync();
 
-            // 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!");
-        }
+        // Assert
+        result.StandardOutput.Trim().Should().Be("Hello Mars!");
     }
 }

CliFx.Tests/ErrorReportingSpecs.cs

@@ -7,199 +7,203 @@ using FluentAssertions;
 using Xunit;
 using Xunit.Abstractions;
 
-namespace CliFx.Tests
+namespace CliFx.Tests;
+
+public class ErrorReportingSpecs : SpecsBase
 {
-    public class ErrorReportingSpecs : SpecsBase
+    public ErrorReportingSpecs(ITestOutputHelper testOutput)
+        : base(testOutput)
     {
-        public ErrorReportingSpecs(ITestOutputHelper testOutput)
-            : base(testOutput)
-        {
-        }
+    }
 
-        [Fact]
-        public async Task Command_can_throw_an_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"");
-}
-");
+    [Fact]
+    public async Task Command_can_throw_an_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");
+            }
+            """
+        );
 
-            var application = new CliApplicationBuilder()
-                .AddCommand(commandType)
-                .UseConsole(FakeConsole)
-                .Build();
+        var application = new CliApplicationBuilder()
+            .AddCommand(commandType)
+            .UseConsole(FakeConsole)
+            .Build();
 
-            // Act
-            var exitCode = await application.RunAsync(
-                Array.Empty<string>(),
-                new Dictionary<string, string>()
-            );
+        // Act
+        var exitCode = await application.RunAsync(
+            Array.Empty<string>(),
+            new Dictionary<string, string>()
+        );
 
-            var stdOut = FakeConsole.ReadOutputString();
-            var stdErr = FakeConsole.ReadErrorString();
+        var stdOut = FakeConsole.ReadOutputString();
+        var stdErr = FakeConsole.ReadErrorString();
 
-            // Assert
-            exitCode.Should().NotBe(0);
-            stdOut.Should().BeEmpty();
-            stdErr.Should().ContainAllInOrder(
-                "System.Exception", "Something went wrong",
-                "at", "CliFx."
-            );
-        }
+        // Assert
+        exitCode.Should().NotBe(0);
+        stdOut.Should().BeEmpty();
+        stdErr.Should().ContainAllInOrder(
+            "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""));
-}
-");
+    [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();
+        var application = new CliApplicationBuilder()
+            .AddCommand(commandType)
+            .UseConsole(FakeConsole)
+            .Build();
 
-            // Act
-            var exitCode = await application.RunAsync(
-                Array.Empty<string>(),
-                new Dictionary<string, string>()
-            );
+        // Act
+        var exitCode = await application.RunAsync(
+            Array.Empty<string>(),
+            new Dictionary<string, string>()
+        );
 
-            var stdOut = FakeConsole.ReadOutputString();
-            var stdErr = FakeConsole.ReadErrorString();
+        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."
-            );
-        }
+        // 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);
-}
-");
+    [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();
+        var application = new CliApplicationBuilder()
+            .AddCommand(commandType)
+            .UseConsole(FakeConsole)
+            .Build();
 
-            // Act
-            var exitCode = await application.RunAsync(
-                Array.Empty<string>(),
-                new Dictionary<string, string>()
-            );
+        // Act
+        var exitCode = await application.RunAsync(
+            Array.Empty<string>(),
+            new Dictionary<string, string>()
+        );
 
-            var stdOut = FakeConsole.ReadOutputString();
-            var stdErr = FakeConsole.ReadErrorString();
+        var stdOut = FakeConsole.ReadOutputString();
+        var stdErr = FakeConsole.ReadErrorString();
 
-            // Assert
-            exitCode.Should().Be(69);
-            stdOut.Should().BeEmpty();
-            stdErr.Trim().Should().Be("Something went wrong");
-        }
+        // 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);
-}
-");
+    [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();
+        var application = new CliApplicationBuilder()
+            .AddCommand(commandType)
+            .UseConsole(FakeConsole)
+            .Build();
 
-            // Act
-            var exitCode = await application.RunAsync(
-                Array.Empty<string>(),
-                new Dictionary<string, string>()
-            );
+        // Act
+        var exitCode = await application.RunAsync(
+            Array.Empty<string>(),
+            new Dictionary<string, string>()
+        );
 
-            var stdOut = FakeConsole.ReadOutputString();
-            var stdErr = FakeConsole.ReadErrorString();
+        var stdOut = FakeConsole.ReadOutputString();
+        var stdErr = FakeConsole.ReadErrorString();
 
-            // Assert
-            exitCode.Should().Be(69);
-            stdOut.Should().BeEmpty();
-            stdErr.Should().ContainAllInOrder(
-                "CliFx.Exceptions.CommandException",
-                "at", "CliFx."
-            );
-        }
+        // 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);
-}
-");
+    [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();
+        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>()
-            );
+        // Act
+        var exitCode = await application.RunAsync(
+            Array.Empty<string>(),
+            new Dictionary<string, string>()
+        );
 
-            var stdOut = FakeConsole.ReadOutputString();
-            var stdErr = FakeConsole.ReadErrorString();
+        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");
-        }
+        // Assert
+        exitCode.Should().Be(69);
+        stdOut.Should().Contain("This will be in help text");
+        stdErr.Trim().Should().Be("Something went wrong");
     }
 }

CliFx.Tests/ParameterBindingSpecs.cs

@@ -6,228 +6,285 @@ using FluentAssertions;
 using Xunit;
 using Xunit.Abstractions;
 
-namespace CliFx.Tests
+namespace CliFx.Tests;
+
+public class ParameterBindingSpecs : SpecsBase
 {
-    public class ParameterBindingSpecs : SpecsBase
+    public ParameterBindingSpecs(ITestOutputHelper testOutput)
+        : base(testOutput)
     {
-        public ParameterBindingSpecs(ITestOutputHelper testOutput)
-            : base(testOutput)
-        {
-        }
-
-        [Fact]
-        public async Task Parameter_is_bound_from_an_argument_matching_its_order()
-        {
-            // Arrange
-            var commandType = DynamicCommandBuilder.Compile(
-                // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
-    [CommandParameter(0)]
-    public string Foo { get; set; }
-    
-    [CommandParameter(1)]
-    public string Bar { get; set; }
-
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""Foo = "" + Foo);
-        console.Output.WriteLine(""Bar = "" + Bar);
-        
-        return default;
     }
-}");
 
-            var application = new CliApplicationBuilder()
-                .AddCommand(commandType)
-                .UseConsole(FakeConsole)
-                .Build();
-
-            // Act
-            var exitCode = await application.RunAsync(
-                new[] {"one", "two"},
-                new Dictionary<string, string>()
-            );
-
-            var stdOut = FakeConsole.ReadOutputString();
-
-            // Assert
-            exitCode.Should().Be(0);
-            stdOut.Should().ConsistOfLines(
-                "Foo = one",
-                "Bar = two"
-            );
-        }
-
-        [Fact]
-        public async Task Parameter_of_non_scalar_type_is_bound_from_remaining_non_option_arguments()
-        {
-            // Arrange
-            var commandType = DynamicCommandBuilder.Compile(
-                // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
-    [CommandParameter(0)]
-    public string Foo { get; set; }
-    
-    [CommandParameter(1)]
-    public string Bar { get; set; }
-    
-    [CommandParameter(2)]
-    public IReadOnlyList<string> Baz { get; set; }
-    
-    [CommandOption(""boo"")]
-    public string Boo { get; set; }
-
-    public ValueTask ExecuteAsync(IConsole console)
+    [Fact]
+    public async Task Parameter_is_bound_from_an_argument_matching_its_order()
     {
-        console.Output.WriteLine(""Foo = "" + Foo);
-        console.Output.WriteLine(""Bar = "" + Bar);
+        // Arrange
+        var commandType = DynamicCommandBuilder.Compile(
+            // language=cs
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandParameter(0)]
+                public string Foo { get; set; }
 
-        foreach (var i in Baz)
-            console.Output.WriteLine(""Baz = "" + i);
+                [CommandParameter(1)]
+                public string Bar { get; set; }
 
-        return default;
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("Foo = " + Foo);
+                    console.Output.WriteLine("Bar = " + Bar);
+
+                    return default;
+                }
+            }
+            """
+        );
+
+        var application = new CliApplicationBuilder()
+            .AddCommand(commandType)
+            .UseConsole(FakeConsole)
+            .Build();
+
+        // Act
+        var exitCode = await application.RunAsync(
+            new[] {"one", "two"},
+            new Dictionary<string, string>()
+        );
+
+        var stdOut = FakeConsole.ReadOutputString();
+
+        // Assert
+        exitCode.Should().Be(0);
+        stdOut.Should().ConsistOfLines(
+            "Foo = one",
+            "Bar = two"
+        );
     }
-}");
 
-            var application = new CliApplicationBuilder()
-                .AddCommand(commandType)
-                .UseConsole(FakeConsole)
-                .Build();
+    [Fact]
+    public async Task Parameter_of_non_scalar_type_is_bound_from_remaining_non_option_arguments()
+    {
+        // Arrange
+        var commandType = DynamicCommandBuilder.Compile(
+            // language=cs
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandParameter(0)]
+                public string Foo { get; set; }
 
-            // Act
-            var exitCode = await application.RunAsync(
-                new[] {"one", "two", "three", "four", "five", "--boo", "xxx"},
-                new Dictionary<string, string>()
-            );
+                [CommandParameter(1)]
+                public string Bar { get; set; }
 
-            var stdOut = FakeConsole.ReadOutputString();
+                [CommandParameter(2)]
+                public IReadOnlyList<string> Baz { get; set; }
 
-            // Assert
-            exitCode.Should().Be(0);
-            stdOut.Should().ConsistOfLines(
-                "Foo = one",
-                "Bar = two",
-                "Baz = three",
-                "Baz = four",
-                "Baz = five"
-            );
-        }
+                [CommandOption("boo")]
+                public string Boo { get; set; }
 
-        [Fact]
-        public async Task Parameter_binding_fails_if_one_of_the_parameters_has_not_been_provided()
-        {
-            // Arrange
-            var commandType = DynamicCommandBuilder.Compile(
-                // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
-    [CommandParameter(0)]
-    public string Foo { get; set; }
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("Foo = " + Foo);
+                    console.Output.WriteLine("Bar = " + Bar);
 
-    [CommandParameter(1)]
-    public string Bar { get; set; }
+                    foreach (var i in Baz)
+                        console.Output.WriteLine("Baz = " + i);
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}");
+                    return default;
+                }
+            }
+            """
+        );
 
-            var application = new CliApplicationBuilder()
-                .AddCommand(commandType)
-                .UseConsole(FakeConsole)
-                .Build();
+        var application = new CliApplicationBuilder()
+            .AddCommand(commandType)
+            .UseConsole(FakeConsole)
+            .Build();
 
-            // Act
-            var exitCode = await application.RunAsync(
-                new[] {"one"},
-                new Dictionary<string, string>()
-            );
+        // Act
+        var exitCode = await application.RunAsync(
+            new[] {"one", "two", "three", "four", "five", "--boo", "xxx"},
+            new Dictionary<string, string>()
+        );
 
-            var stdErr = FakeConsole.ReadErrorString();
+        var stdOut = FakeConsole.ReadOutputString();
 
-            // Assert
-            exitCode.Should().NotBe(0);
-            stdErr.Should().Contain("Missing parameter(s)");
-        }
+        // Assert
+        exitCode.Should().Be(0);
+        stdOut.Should().ConsistOfLines(
+            "Foo = one",
+            "Bar = two",
+            "Baz = three",
+            "Baz = four",
+            "Baz = five"
+        );
+    }
 
-        [Fact]
-        public async Task Parameter_binding_fails_if_a_parameter_of_non_scalar_type_has_not_been_provided_with_at_least_one_value()
-        {
-            // Arrange
-            var commandType = DynamicCommandBuilder.Compile(
-                // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
-    [CommandParameter(0)]
-    public string Foo { get; set; }
+    [Fact]
+    public async Task Parameter_is_not_bound_if_there_are_no_arguments_matching_its_order()
+    {
+        // Arrange
+        var commandType = DynamicCommandBuilder.Compile(
+            // language=cs
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandParameter(0)]
+                public string Foo { get; set; }
 
-    [CommandParameter(1)]
-    public IReadOnlyList<string> Bar { get; set; }
+                [CommandParameter(1, IsRequired = false)]
+                public string Bar { get; set; } = "xyz";
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}");
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("Foo = " + Foo);
+                    console.Output.WriteLine("Bar = " + Bar);
 
-            var application = new CliApplicationBuilder()
-                .AddCommand(commandType)
-                .UseConsole(FakeConsole)
-                .Build();
+                    return default;
+                }
+            }
+            """
+        );
 
-            // Act
-            var exitCode = await application.RunAsync(
-                new[] {"one"},
-                new Dictionary<string, string>()
-            );
+        var application = new CliApplicationBuilder()
+            .AddCommand(commandType)
+            .UseConsole(FakeConsole)
+            .Build();
 
-            var stdErr = FakeConsole.ReadErrorString();
+        // Act
+        var exitCode = await application.RunAsync(
+            new[] {"abc"},
+            new Dictionary<string, string>()
+        );
 
-            // Assert
-            exitCode.Should().NotBe(0);
-            stdErr.Should().Contain("Missing parameter(s)");
-        }
+        var stdOut = FakeConsole.ReadOutputString();
 
-        [Fact]
-        public async Task Parameter_binding_fails_if_one_of_the_provided_parameters_is_unexpected()
-        {
-            // Arrange
-            var commandType = DynamicCommandBuilder.Compile(
-                // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
-    [CommandParameter(0)]
-    public string Foo { get; set; }
+        // Assert
+        exitCode.Should().Be(0);
+        stdOut.Should().ConsistOfLines(
+            "Foo = abc",
+            "Bar = xyz"
+        );
+    }
 
-    [CommandParameter(1)]
-    public string Bar { get; set; }
+    [Fact]
+    public async Task Parameter_binding_fails_if_a_required_parameter_has_not_been_provided()
+    {
+        // Arrange
+        var commandType = DynamicCommandBuilder.Compile(
+            // language=cs
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandParameter(0)]
+                public string Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}");
+                [CommandParameter(1)]
+                public string Bar { get; set; }
 
-            var application = new CliApplicationBuilder()
-                .AddCommand(commandType)
-                .UseConsole(FakeConsole)
-                .Build();
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """
+        );
 
-            // Act
-            var exitCode = await application.RunAsync(
-                new[] {"one", "two", "three"},
-                new Dictionary<string, string>()
-            );
+        var application = new CliApplicationBuilder()
+            .AddCommand(commandType)
+            .UseConsole(FakeConsole)
+            .Build();
 
-            var stdErr = FakeConsole.ReadErrorString();
+        // Act
+        var exitCode = await application.RunAsync(
+            new[] {"one"},
+            new Dictionary<string, string>()
+        );
 
-            // Assert
-            exitCode.Should().NotBe(0);
-            stdErr.Should().Contain("Unexpected parameter(s)");
-        }
+        var stdErr = FakeConsole.ReadErrorString();
+
+        // Assert
+        exitCode.Should().NotBe(0);
+        stdErr.Should().Contain("Missing required parameter(s)");
+    }
+
+    [Fact]
+    public async Task Parameter_binding_fails_if_a_parameter_of_non_scalar_type_has_not_been_provided_with_at_least_one_value()
+    {
+        // Arrange
+        var commandType = DynamicCommandBuilder.Compile(
+            // language=cs
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandParameter(0)]
+                public string Foo { get; set; }
+
+                [CommandParameter(1)]
+                public IReadOnlyList<string> Bar { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """
+        );
+
+        var application = new CliApplicationBuilder()
+            .AddCommand(commandType)
+            .UseConsole(FakeConsole)
+            .Build();
+
+        // Act
+        var exitCode = await application.RunAsync(
+            new[] {"one"},
+            new Dictionary<string, string>()
+        );
+
+        var stdErr = FakeConsole.ReadErrorString();
+
+        // Assert
+        exitCode.Should().NotBe(0);
+        stdErr.Should().Contain("Missing required parameter(s)");
+    }
+
+    [Fact]
+    public async Task Parameter_binding_fails_if_one_of_the_provided_parameters_is_unexpected()
+    {
+        // Arrange
+        var commandType = DynamicCommandBuilder.Compile(
+            // language=cs
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandParameter(0)]
+                public string Foo { get; set; }
+
+                [CommandParameter(1)]
+                public string Bar { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """
+        );
+
+        var application = new CliApplicationBuilder()
+            .AddCommand(commandType)
+            .UseConsole(FakeConsole)
+            .Build();
+
+        // Act
+        var exitCode = await application.RunAsync(
+            new[] {"one", "two", "three"},
+            new Dictionary<string, string>()
+        );
+
+        var stdErr = FakeConsole.ReadErrorString();
+
+        // Assert
+        exitCode.Should().NotBe(0);
+        stdErr.Should().Contain("Unexpected parameter(s)");
     }
 }

CliFx.Tests/RoutingSpecs.cs

@@ -6,181 +6,183 @@ using FluentAssertions;
 using Xunit;
 using Xunit.Abstractions;
 
-namespace CliFx.Tests
-{
-    public class RoutingSpecs : SpecsBase
-    {
-        public RoutingSpecs(ITestOutputHelper testOutput)
-            : base(testOutput)
-        {
-        }
+namespace CliFx.Tests;
 
-        [Fact]
-        public async Task Default_command_is_executed_if_provided_arguments_do_not_match_any_named_command()
-        {
-            // Arrange
-            var commandTypes = DynamicCommandBuilder.CompileMany(
-                // language=cs
-                @"
-[Command]
-public class DefaultCommand : ICommand
+public class RoutingSpecs : SpecsBase
 {
-    public ValueTask ExecuteAsync(IConsole console)
+    public RoutingSpecs(ITestOutputHelper testOutput)
+        : base(testOutput)
     {
-        console.Output.WriteLine(""default"");
-        return default;
-    }
-}
-
-[Command(""cmd"")]
-public class NamedCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""cmd"");
-        return default;
-    }
-}
-
-[Command(""cmd child"")]
-public class NamedChildCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""cmd child"");
-        return default;
-    }
-}
-");
-
-            var application = new CliApplicationBuilder()
-                .AddCommands(commandTypes)
-                .UseConsole(FakeConsole)
-                .Build();
-
-            // Act
-            var exitCode = await application.RunAsync(
-                Array.Empty<string>(),
-                new Dictionary<string, string>()
-            );
-
-            var stdOut = FakeConsole.ReadOutputString();
-
-            // Assert
-            exitCode.Should().Be(0);
-            stdOut.Trim().Should().Be("default");
-        }
-
-        [Fact]
-        public async Task Specific_named_command_is_executed_if_provided_arguments_match_its_name()
-        {
-            // Arrange
-            var commandTypes = DynamicCommandBuilder.CompileMany(
-                // language=cs
-                @"
-[Command]
-public class DefaultCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""default"");
-        return default;
-    }
-}
-
-[Command(""cmd"")]
-public class NamedCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""cmd"");
-        return default;
-    }
-}
-
-[Command(""cmd child"")]
-public class NamedChildCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""cmd child"");
-        return default;
-    }
-}
-");
-
-            var application = new CliApplicationBuilder()
-                .AddCommands(commandTypes)
-                .UseConsole(FakeConsole)
-                .Build();
-
-            // Act
-            var exitCode = await application.RunAsync(
-                new[] {"cmd"},
-                new Dictionary<string, string>()
-            );
-
-            var stdOut = FakeConsole.ReadOutputString();
-
-            // Assert
-            exitCode.Should().Be(0);
-            stdOut.Trim().Should().Be("cmd");
-        }
-
-        [Fact]
-        public async Task Specific_named_child_command_is_executed_if_provided_arguments_match_its_name()
-        {
-            // Arrange
-            var commandTypes = DynamicCommandBuilder.CompileMany(
-                // language=cs
-                @"
-[Command]
-public class DefaultCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""default"");
-        return default;
-    }
-}
-
-[Command(""cmd"")]
-public class NamedCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""cmd"");
-        return default;
-    }
-}
-
-[Command(""cmd child"")]
-public class NamedChildCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""cmd child"");
-        return default;
-    }
-}
-");
-
-            var application = new CliApplicationBuilder()
-                .AddCommands(commandTypes)
-                .UseConsole(FakeConsole)
-                .Build();
-
-            // Act
-            var exitCode = await application.RunAsync(
-                new[] {"cmd", "child"},
-                new Dictionary<string, string>()
-            );
-
-            var stdOut = FakeConsole.ReadOutputString();
-
-            // Assert
-            exitCode.Should().Be(0);
-            stdOut.Trim().Should().Be("cmd child");
-        }
+    }
+
+    [Fact]
+    public async Task Default_command_is_executed_if_provided_arguments_do_not_match_any_named_command()
+    {
+        // Arrange
+        var commandTypes = DynamicCommandBuilder.CompileMany(
+            // language=cs
+            """
+            [Command]
+            public class DefaultCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("default");
+                    return default;
+                }
+            }
+
+            [Command("cmd")]
+            public class NamedCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("cmd");
+                    return default;
+                }
+            }
+
+            [Command("cmd child")]
+            public class NamedChildCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("cmd child");
+                    return default;
+                }
+            }
+            """
+        );
+
+        var application = new CliApplicationBuilder()
+            .AddCommands(commandTypes)
+            .UseConsole(FakeConsole)
+            .Build();
+
+        // Act
+        var exitCode = await application.RunAsync(
+            Array.Empty<string>(),
+            new Dictionary<string, string>()
+        );
+
+        var stdOut = FakeConsole.ReadOutputString();
+
+        // Assert
+        exitCode.Should().Be(0);
+        stdOut.Trim().Should().Be("default");
+    }
+
+    [Fact]
+    public async Task Specific_named_command_is_executed_if_provided_arguments_match_its_name()
+    {
+        // Arrange
+        var commandTypes = DynamicCommandBuilder.CompileMany(
+            // language=cs
+            """
+            [Command]
+            public class DefaultCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("default");
+                    return default;
+                }
+            }
+
+            [Command("cmd")]
+            public class NamedCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("cmd");
+                    return default;
+                }
+            }
+
+            [Command("cmd child")]
+            public class NamedChildCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("cmd child");
+                    return default;
+                }
+            }
+            """
+        );
+
+        var application = new CliApplicationBuilder()
+            .AddCommands(commandTypes)
+            .UseConsole(FakeConsole)
+            .Build();
+
+        // Act
+        var exitCode = await application.RunAsync(
+            new[] {"cmd"},
+            new Dictionary<string, string>()
+        );
+
+        var stdOut = FakeConsole.ReadOutputString();
+
+        // Assert
+        exitCode.Should().Be(0);
+        stdOut.Trim().Should().Be("cmd");
+    }
+
+    [Fact]
+    public async Task Specific_named_child_command_is_executed_if_provided_arguments_match_its_name()
+    {
+        // Arrange
+        var commandTypes = DynamicCommandBuilder.CompileMany(
+            // language=cs
+            """
+            [Command]
+            public class DefaultCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("default");
+                    return default;
+                }
+            }
+
+            [Command("cmd")]
+            public class NamedCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("cmd");
+                    return default;
+                }
+            }
+
+            [Command("cmd child")]
+            public class NamedChildCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("cmd child");
+                    return default;
+                }
+            }
+            """
+        );
+
+        var application = new CliApplicationBuilder()
+            .AddCommands(commandTypes)
+            .UseConsole(FakeConsole)
+            .Build();
+
+        // Act
+        var exitCode = await application.RunAsync(
+            new[] {"cmd", "child"},
+            new Dictionary<string, string>()
+        );
+
+        var stdOut = FakeConsole.ReadOutputString();
+
+        // Assert
+        exitCode.Should().Be(0);
+        stdOut.Trim().Should().Be("cmd child");
     }
 }