Update version

Closes #135

.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,7 +1,99 @@
-### v2.0 (21-Mar-2021)
+# Changelog
+
+## v2.3.3 (28-Apr-2023)
+
+- Fixed an issue where the analyzers failed to load in some projects, due to targeting a Roslyn version that was too high.
+
+## v2.3.2 (06-Apr-2023)
+
+- Added name-based ordering to subcommands when displayed in the help text. (Thanks [@CartBlanche](https://github.com/CartBlanche))
+
+## 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))
+
+## v2.0.2 (31-Mar-2021)
+
+- Fixed an issue where having a transitive reference to CliFx sometimes resulted in `SystemConsoleShouldBeAvoidedAnalyzer` throwing `NullReferenceException` during build.
+- Fixed some documentation typos and inconsistencies.
+
+## v2.0.1 (24-Mar-2021)
+
+- Fixed an issue where some exceptions with async stack traces generated on .NET 3.1 or earlier were not parsed and formatted correctly.
+- Fixed an issue where help text applied slightly incorrect formatting when displaying choices for enum-based parameters and properties.
+
+## v2.0 (21-Mar-2021)
 
 > Note: this major release includes many breaking changes.
-Please refer to the readme to find updated instructions and usage examples.
+> 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.
@@ -18,7 +110,7 @@ Please refer to the readme to find updated instructions and usage examples.
   - Assigned separate colors to parameters and options to make them visually stand out
   - Usage section no longer lists usage formats of all descendant commands
   - Command section now also lists available subcommands for each of the current command's subcommands
-- Changed the behavior of `[preview]` directive. Running the application with this directive will now also print all resolved environment variables, in addition to parsed command line arguments.
+- Changed the behavior of `[preview]` directive. Running the application with this directive will now also print all resolved environment variables, in addition to parsed command-line arguments.
 - Reworked `IArgumentValueConverter`/`ArgumentValueConverter` into `BindingConverter`. Method `ConvertFrom(...)` has been renamed to `Convert(...)`.
 - Reworked `ArgumentValueValidator` into `BindingValidator`. This class exposes an abstract `Validate(...)` method that returns a nullable `BindingValidationError`. This class also provides utility methods `Ok()` and `Error(...)` to help create corresponding validation results.
 - Changed the type of `IConsole.Output` and `IConsole.Error` from `StreamWriter` to `ConsoleWriter`. This type derives from `StreamWriter` and additionally exposes a `Console` property that refers to the console instance that owns the stream. This change enables you to author extension methods scoped specifically to console output and error streams.
@@ -32,34 +124,34 @@ Please refer to the readme to find updated instructions and usage examples.
   - `ITypeActivator`/`DefaultTypeActivator`/`DelegateTypeActivator` moved from `CliFx` to `CliFx.Infrastructure`
   - `BindingValidator`/`BindingConverter` moved from `CliFx` to `CliFx.Extensibility`
 
-### v1.6 (06-Dec-2020)
+## v1.6 (06-Dec-2020)
 
 - Added support for custom value validators. You can now create a type that inherits from `CliFx.ArgumentValueValidator<T>` to implement reusable validation logic for command arguments. To use a validator, include it in the `Validators` property on the `CommandOption` or `CommandParameter` attribute. (Thanks [@Oleksandr Shustov](https://github.com/AlexandrShustov))
 - Added `CliFx.ArgumentValueConverter<T>` class that you can inherit from to implement custom value converters. `CliFx.IArgumentValueConverter` interface is still available, but it is recommended to inherit from the generic class instead, due to the type safety it provides. The interface may become internal or get removed in one of the future major versions.
 - Updated requirements for option names and short names: short names now must be letter characters (lowercase or uppercase), while names must now start with a letter character. This means option names can no longer start with a digit or a special character. This change makes it possible to pass negative number values without the need to quote them, i.e. `--my-number -5`.
 
-### v1.5 (23-Oct-2020)
+## v1.5 (23-Oct-2020)
 
 - Added pretty-printing for unhandled exceptions thrown from within the application. This makes the errors easier to parse visually and should help in troubleshooting. This change does not affect `CommandException`, as it already has special treatment. (Thanks [@Mårten Åsberg](https://github.com/89netraM))
 - Added support for custom value converters. You can now create a type that implements `CliFx.IArgumentValueConverter` and specify it as a converter for your parameters or options via the `Converter` named property. This should enable conversion between raw argument values and custom types which are not string-initializable. (Thanks [@Oleksandr Shustov](https://github.com/AlexandrShustov))
 - Improved help text so that it also shows minimal usage examples for child and descendant commands, besides the actual command it was requested on. This should improve user experience for applications with many nested commands. (Thanks [@Nikiforov Alexey](https://github.com/NikiforovAll))
 
-### v1.4 (20-Aug-2020)
+## v1.4 (20-Aug-2020)
 
 - Added `VirtualConsole.CreateBuffered()` method to simplify test setup when using in-memory backing stores for output and error streams. Please refer to the readme for updated recommendations on how to test applications built with CliFx.
 - Added generic `CliApplicationBuilder.AddCommand<TCommand>()`. This overload simplifies adding commands one-by-one as it also checks that the type implements `ICommand`.
 
-### v1.3.2 (31-Jul-2020)
+## v1.3.2 (31-Jul-2020)
 
 - Fixed an issue where a command was incorrectly allowed to execute when the user did not specify any value for a non-scalar parameter. Since they are always required, a parameter needs to be bound to at least one value. (Thanks [@Daniel Hix](https://github.com/ADustyOldMuffin))
 - Fixed an issue where `CliApplication.RunAsync(...)` threw `ArgumentException` if there were two environment variables, whose names differed only in case. Environment variable names are now treated case-sensitively. (Thanks [@Ron Myers](https://github.com/ron-myers))
 
-### v1.3.1 (19-Jul-2020)
+## v1.3.1 (19-Jul-2020)
 
 - Running the application with the debug directive (`myapp [debug]`) will now also try to launch a debugger instance. In most cases it will save time as you won't need to attach the debugger manually. (Thanks [@Volodymyr Shkolka](https://github.com/BlackGad))
 - Fixed an issue where unhandled generic exceptions (i.e. not `CommandException`) sometimes caused the application to incorrectly return successful exit code due to an overflow issue on Unix systems. Starting from this version, all unhandled generic exceptions will produce `1` as the exit code when thrown. Instances of `CommandException` can still be configured to return any specified exit code, but it's recommended to constrain the values between `1` and `255` to avoid overflow issues. (Thanks [@Ihor Nechyporuk](https://github.com/inech))
 
-### v1.3 (23-May-2020)
+## v1.3 (23-May-2020)
 
 - Changed analyzers to report errors instead of warnings. If you find that some analyzer works incorrectly, please report it on GitHub. You can also configure inspection severity overrides in your project if you need to.
 - Improved help text by showing default values for non-required options. This only works on types that have a custom override for `ToString()` method. Additionally, if the type implements `IFormattable`, the overload with a format provider will be used instead. (Thanks [@Domn Werner](https://github.com/domn1995))
@@ -67,7 +159,7 @@ Please refer to the readme to find updated instructions and usage examples.
 - Fixed an issue where it was possible to define a command with an option that has the same name or short name as built-in help or version options. Previously it would lead to the user-defined option being ignored in favor of the built-in option. Now this will throw an exception instead.
 - Changed the underlying representation of `StreamReader`/`StreamWriter` objects used in `SystemConsole` and `VirtualConsole` to be thread-safe.
 
-### v1.2 (11-May-2020)
+## v1.2 (11-May-2020)
 
 - Added built-in Roslyn analyzers that help catch incorrect usage of the library. Currently, all analyzers report issues as warnings so as to not prevent the project from building. In the future that may change.
 - Added an optional parameter to `new CommandException(...)` called `showHelp` which can be used to instruct CliFx to show help for the current command after printing the error. (Thanks [@Domn Werner](https://github.com/domn1995))
@@ -78,7 +170,7 @@ Please refer to the readme to find updated instructions and usage examples.
 - Improved exception messages.
 - Improved exceptions related to user input by also showing help text after the error message. (Thanks [@Domn Werner](https://github.com/domn1995))
 
-### v1.1 (16-Mar-2020)
+## v1.1 (16-Mar-2020)
 
 - Changed `IConsole` interface (and as a result, `SystemConsole` and `VirtualConsole`) to support writing binary data. Instead of `TextReader`/`TextWriter` instances, the streams are now exposed as `StreamReader`/`StreamWriter` which provide the `BaseStream` property that allows raw access. Existing usages inside commands should remain the same because `StreamReader`/`StreamWriter` are compatible with their base classes `TextReader`/`TextWriter`, but if you were using `VirtualConsole` in tests, you may have to update it to the new API. Refer to the readme for more info.
 - Changed argument binding behavior so that an error is produced if the user provides an argument that doesn't match with any parameter or option. This is done in order to improve user experience, as otherwise the user may make a typo without knowing that their input wasn't taken into account.

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.2" PrivateAssets="all" />
+    <PackageReference Include="FluentAssertions" Version="6.11.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.5.0" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.5.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,10 +2,10 @@
 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]
@@ -13,11 +13,13 @@ namespace CliFx.Analyzers.Tests
     {
         // Arrange
         // language=cs
-            const string code = @"
-public class MyCommand : ICommand
-{
+        const string code =
+            """
+            public class MyCommand : ICommand
+            {
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -28,12 +30,14 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public abstract class MyCommand : ICommand
-{
+        const string code =
+            """
+            [Command]
+            public abstract class MyCommand : ICommand
+            {
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -44,11 +48,13 @@ public abstract class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-            const string code = @"
-public abstract class MyCommand : ICommand
-{
+        const string code =
+            """
+            public abstract class MyCommand : ICommand
+            {
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -59,14 +65,15 @@ public abstract class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-            const string code = @"
-public class Foo
-{
+        const string code =
+            """
+            public class Foo
+            {
                 public int Bar { get; set; } = 5;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
     }
-    }
 }

CliFx.Analyzers.Tests/CommandMustImplementInterfaceAnalyzerSpecs.cs

@@ -2,10 +2,10 @@
 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]
@@ -13,12 +13,14 @@ namespace CliFx.Analyzers.Tests
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand
-{
+        const string code =
+            """
+            [Command]
+            public class MyCommand
+            {
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -29,12 +31,14 @@ public class MyCommand
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -45,14 +49,15 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-            const string code = @"
-public class Foo
-{
+        const string code =
+            """
+            public class Foo
+            {
                 public int Bar { get; set; } = 5;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
     }
-    }
 }

CliFx.Analyzers.Tests/GeneralSpecs.cs

@@ -4,10 +4,10 @@ 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()
     {
@@ -27,5 +27,4 @@ namespace CliFx.Analyzers.Tests
         // Assert
         diagnosticIds.Should().OnlyHaveUniqueItems();
     }
-    }
 }

CliFx.Analyzers.Tests/OptionMustBeInsideCommandAnalyzerSpecs.cs

@@ -2,10 +2,10 @@
 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]
@@ -13,12 +13,14 @@ namespace CliFx.Analyzers.Tests
     {
         // Arrange
         // language=cs
-            const string code = @"
-public class MyClass
-{
-    [CommandOption(""foo"")]
+        const string code =
+            """
+            public class MyClass
+            {
+                [CommandOption("foo")]
                 public string Foo { get; set; }
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -29,15 +31,17 @@ public class MyClass
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption(""foo"")]
+        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);
@@ -48,12 +52,14 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-            const string code = @"
-public abstract class MyCommand
-{
-    [CommandOption(""foo"")]
+        const string code =
+            """
+            public abstract class MyCommand
+            {
+                [CommandOption("foo")]
                 public string Foo { get; set; }
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -64,17 +70,18 @@ public abstract class MyCommand
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
+        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/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,10 +2,10 @@
 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]
@@ -13,15 +13,17 @@ namespace CliFx.Analyzers.Tests
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
                 [CommandOption(null)]
                 public string Foo { get; set; }
             
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -32,15 +34,17 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption(""foo"")]
+        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);
@@ -51,15 +55,17 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
                 [CommandOption('f')]
                 public string Foo { get; set; }
             
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -70,17 +76,18 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
                 public string Foo { get; set; }
             
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
     }
-    }
 }

CliFx.Analyzers.Tests/OptionMustHaveUniqueNameAnalyzerSpecs.cs

@@ -2,10 +2,10 @@
 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]
@@ -13,18 +13,20 @@ namespace CliFx.Analyzers.Tests
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption(""foo"")]
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("foo")]
                 public string Foo { get; set; }
             
-    [CommandOption(""foo"")]
+                [CommandOption("foo")]
                 public string Bar { get; set; }
             
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -35,18 +37,20 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption(""foo"")]
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("foo")]
                 public string Foo { get; set; }
             
-    [CommandOption(""bar"")]
+                [CommandOption("bar")]
                 public string Bar { get; set; }
             
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -57,15 +61,17 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
                 [CommandOption('f')]
                 public string Foo { get; set; }
             
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -76,17 +82,18 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
                 public string Foo { get; set; }
             
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
     }
-    }
 }

CliFx.Analyzers.Tests/OptionMustHaveUniqueShortNameAnalyzerSpecs.cs

@@ -2,10 +2,10 @@
 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]
@@ -13,10 +13,11 @@ namespace CliFx.Analyzers.Tests
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
                 [CommandOption('f')]
                 public string Foo { get; set; }
             
@@ -24,7 +25,8 @@ public class MyCommand : ICommand
                 public string Bar { get; set; }
             
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -35,10 +37,11 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
                 [CommandOption('f')]
                 public string Foo { get; set; }
             
@@ -46,7 +49,8 @@ public class MyCommand : ICommand
                 public string Bar { get; set; }
             
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -57,10 +61,11 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
                 [CommandOption('f')]
                 public string Foo { get; set; }
             
@@ -68,7 +73,8 @@ public class MyCommand : ICommand
                 public string Bar { get; set; }
             
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -79,15 +85,17 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption(""foo"")]
+        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);
@@ -98,17 +106,18 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
                 public string Foo { get; set; }
             
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
     }
-    }
 }

CliFx.Analyzers.Tests/OptionMustHaveValidConverterAnalyzerSpecs.cs

@@ -2,55 +2,137 @@
 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_the_specified_option_converter_does_not_derive_from_BindingConverter()
+    public void Analyzer_reports_an_error_if_an_option_has_a_converter_that_does_not_derive_from_BindingConverter()
     {
         // Arrange
         // language=cs
-            const string code = @"
-public class MyConverter
-{
+        const string code =
+            """
+            public class MyConverter
+            {
                 public string Convert(string rawValue) => rawValue;
-}
+            }
             
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption(""foo"", Converter = typeof(MyConverter))]
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("foo", Converter = typeof(MyConverter))]
                 public string Foo { get; set; }
             
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
     }
 
     [Fact]
-        public void Analyzer_does_not_report_an_error_if_the_specified_option_converter_derives_from_BindingConverter()
+    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<string>
-{
-    public override string Convert(string rawValue) => rawValue;
-}
+        const string code =
+            """
+            public class MyConverter : BindingConverter<int>
+            {
+                public override int Convert(string rawValue) => 42;
+            }
             
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption(""foo"", Converter = typeof(MyConverter))]
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("foo", Converter = typeof(MyConverter))]
                 public string Foo { get; set; }
             
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_an_option_has_a_converter_that_derives_from_a_compatible_BindingConverter()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            public class MyConverter : BindingConverter<string>
+            {
+                public override string Convert(string rawValue) => rawValue;
+            }
+            
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("foo", Converter = typeof(MyConverter))]
+                public string Foo { get; set; }
+            
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_nullable_option_has_a_converter_that_derives_from_a_compatible_BindingConverter()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            public class MyConverter : BindingConverter<int>
+            {
+                public override int Convert(string rawValue) => 42;
+            }
+            
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("foo", Converter = typeof(MyConverter))]
+                public int? Foo { get; set; }
+            
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_non_scalar_option_has_a_converter_that_derives_from_a_compatible_BindingConverter()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            public class MyConverter : BindingConverter<string>
+            {
+                public override string Convert(string rawValue) => rawValue;
+            }
+            
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("foo", Converter = typeof(MyConverter))]
+                public IReadOnlyList<string> Foo { get; set; }
+            
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -61,15 +143,17 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption(""foo"")]
+        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);
@@ -80,17 +164,18 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
+        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,10 +2,10 @@
 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]
@@ -13,15 +13,17 @@ namespace CliFx.Analyzers.Tests
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption(""f"")]
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("f")]
                 public string Foo { get; set; }
             
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -32,15 +34,17 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption(""1foo"")]
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("1foo")]
                 public string Foo { get; set; }
             
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -51,15 +55,17 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption(""foo"")]
+        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);
@@ -70,15 +76,17 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
                 [CommandOption('f')]
                 public string Foo { get; set; }
             
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -89,17 +97,18 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
                 public string Foo { get; set; }
             
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
     }
-    }
 }

CliFx.Analyzers.Tests/OptionMustHaveValidShortNameAnalyzerSpecs.cs

@@ -2,10 +2,10 @@
 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]
@@ -13,15 +13,17 @@ namespace CliFx.Analyzers.Tests
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
                 [CommandOption('1')]
                 public string Foo { get; set; }
             
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -32,15 +34,17 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
                 [CommandOption('f')]
                 public string Foo { get; set; }
             
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -51,15 +55,17 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption(""foo"")]
+        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);
@@ -70,17 +76,18 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
                 public string Foo { get; set; }
             
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
     }
-    }
 }

CliFx.Analyzers.Tests/OptionMustHaveValidValidatorsAnalyzerSpecs.cs

@@ -2,55 +2,85 @@
 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_one_of_the_specified_option_validators_does_not_derive_from_BindingValidator()
+    public void Analyzer_reports_an_error_if_an_option_has_a_validator_that_does_not_derive_from_BindingValidator()
     {
         // Arrange
         // language=cs
-            const string code = @"
-public class MyValidator
-{
+        const string code =
+            """
+            public class MyValidator
+            {
                 public void Validate(string value) {}
-}
+            }
             
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption(""foo"", Validators = new[] {typeof(MyValidator)})]
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("foo", Validators = new[] {typeof(MyValidator)})]
                 public string Foo { get; set; }
             
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
     }
 
     [Fact]
-        public void Analyzer_does_not_report_an_error_if_all_specified_option_validators_derive_from_BindingValidator()
+    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<string>
-{
-    public override BindingValidationError Validate(string value) => Ok();
-}
+        const string code =
+            """
+            public class MyValidator : BindingValidator<int>
+            {
+                public override BindingValidationError Validate(int value) => Ok();
+            }
             
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption(""foo"", Validators = new[] {typeof(MyValidator)})]
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("foo", Validators = new[] {typeof(MyValidator)})]
                 public string Foo { get; set; }
             
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_an_option_has_validators_that_all_derive_from_compatible_BindingValidators()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            public class MyValidator : BindingValidator<string>
+            {
+                public override BindingValidationError Validate(string value) => Ok();
+            }
+            
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("foo", Validators = new[] {typeof(MyValidator)})]
+                public string Foo { get; set; }
+            
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -61,15 +91,17 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption(""foo"")]
+        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);
@@ -80,17 +112,18 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
+        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,10 +2,10 @@
 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]
@@ -13,12 +13,14 @@ namespace CliFx.Analyzers.Tests
     {
         // Arrange
         // language=cs
-            const string code = @"
-public class MyClass
-{
+        const string code =
+            """
+            public class MyClass
+            {
                 [CommandParameter(0)]
                 public string Foo { get; set; }
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -29,15 +31,17 @@ public class MyClass
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
+        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);
@@ -48,12 +52,14 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-            const string code = @"
-public abstract class MyCommand
-{
+        const string code =
+            """
+            public abstract class MyCommand
+            {
                 [CommandParameter(0)]
                 public string Foo { get; set; }
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -64,17 +70,18 @@ public abstract class MyCommand
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
+        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/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,21 +2,22 @@
 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_last_in_order()
+    public void Analyzer_reports_an_error_if_a_non_scalar_parameter_is_not_the_last_in_order()
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
                 [CommandParameter(0)]
                 public string[] Foo { get; set; }
             
@@ -24,21 +25,23 @@ public class MyCommand : ICommand
                 public string Bar { get; set; }
             
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
     }
 
     [Fact]
-        public void Analyzer_does_not_report_an_error_if_a_non_scalar_parameter_is_last_in_order()
+    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
-{
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
                 [CommandParameter(0)]
                 public string Foo { get; set; }
             
@@ -46,7 +49,8 @@ public class MyCommand : ICommand
                 public string[] Bar { get; set; }
             
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -57,10 +61,11 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
                 [CommandParameter(0)]
                 public string Foo { get; set; }
             
@@ -68,7 +73,8 @@ public class MyCommand : ICommand
                 public string Bar { get; set; }
             
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -79,17 +85,18 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
+        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/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,10 +2,10 @@
 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]
@@ -13,10 +13,11 @@ namespace CliFx.Analyzers.Tests
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
                 [CommandParameter(0)]
                 public string[] Foo { get; set; }
             
@@ -24,7 +25,8 @@ public class MyCommand : ICommand
                 public string[] Bar { get; set; }
             
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -35,10 +37,11 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
                 [CommandParameter(0)]
                 public string Foo { get; set; }
             
@@ -46,7 +49,8 @@ public class MyCommand : ICommand
                 public string[] Bar { get; set; }
             
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -57,10 +61,11 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
                 [CommandParameter(0)]
                 public string Foo { get; set; }
             
@@ -68,7 +73,8 @@ public class MyCommand : ICommand
                 public string Bar { get; set; }
             
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -79,17 +85,18 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
                 public string Foo { get; set; }
             
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
     }
-    }
 }

CliFx.Analyzers.Tests/ParameterMustHaveUniqueNameAnalyzerSpecs.cs

@@ -2,10 +2,10 @@
 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]
@@ -13,18 +13,20 @@ namespace CliFx.Analyzers.Tests
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandParameter(0, Name = ""foo"")]
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0, Name = "foo")]
                 public string Foo { get; set; }
             
-    [CommandParameter(1, Name = ""foo"")]
+                [CommandParameter(1, Name = "foo")]
                 public string Bar { get; set; }
             
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -35,18 +37,20 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandParameter(0, Name = ""foo"")]
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0, Name = "foo")]
                 public string Foo { get; set; }
             
-    [CommandParameter(1, Name = ""bar"")]
+                [CommandParameter(1, Name = "bar")]
                 public string Bar { get; set; }
             
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -57,17 +61,18 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
                 public string Foo { get; set; }
             
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
     }
-    }
 }

CliFx.Analyzers.Tests/ParameterMustHaveUniqueOrderAnalyzerSpecs.cs

@@ -2,10 +2,10 @@
 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]
@@ -13,10 +13,11 @@ namespace CliFx.Analyzers.Tests
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
                 [CommandParameter(0)]
                 public string Foo { get; set; }
             
@@ -24,7 +25,8 @@ public class MyCommand : ICommand
                 public string Bar { get; set; }
             
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -35,10 +37,11 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
                 [CommandParameter(0)]
                 public string Foo { get; set; }
             
@@ -46,7 +49,8 @@ public class MyCommand : ICommand
                 public string Bar { get; set; }
             
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -57,17 +61,18 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
                 public string Foo { get; set; }
             
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
     }
-    }
 }

CliFx.Analyzers.Tests/ParameterMustHaveValidConverterAnalyzerSpecs.cs

@@ -2,55 +2,138 @@
 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_the_specified_parameter_converter_does_not_derive_from_BindingConverter()
+    public void Analyzer_reports_an_error_if_a_parameter_has_a_converter_that_does_not_derive_from_BindingConverter()
     {
         // Arrange
         // language=cs
-            const string code = @"
-public class MyConverter
-{
+        const string code =
+            """
+            public class MyConverter
+            {
                 public string Convert(string rawValue) => rawValue;
-}
+            }
             
-[Command]
-public class MyCommand : ICommand
-{
+            [Command]
+            public class MyCommand : ICommand
+            {
                 [CommandParameter(0, Converter = typeof(MyConverter))]
                 public string Foo { get; set; }
             
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
     }
 
     [Fact]
-        public void Analyzer_does_not_report_an_error_if_the_specified_parameter_converter_derives_from_BindingConverter()
+    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<string>
-{
-    public override string Convert(string rawValue) => rawValue;
-}
+        const string code =
+            """
+            public class MyConverter : BindingConverter<int>
+            {
+                public override int Convert(string rawValue) => 42;
+            }
             
-[Command]
-public class MyCommand : ICommand
-{
+            [Command]
+            public class MyCommand : ICommand
+            {
                 [CommandParameter(0, Converter = typeof(MyConverter))]
                 public string Foo { get; set; }
             
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
+
+
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_parameter_has_a_converter_that_derives_from_a_compatible_BindingConverter()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            public class MyConverter : BindingConverter<string>
+            {
+                public override string Convert(string rawValue) => rawValue;
+            }
+            
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0, Converter = typeof(MyConverter))]
+                public string Foo { get; set; }
+            
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_nullable_parameter_has_a_converter_that_derives_from_a_compatible_BindingConverter()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            public class MyConverter : BindingConverter<int>
+            {
+                public override int Convert(string rawValue) => 42;
+            }
+            
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("foo", Converter = typeof(MyConverter))]
+                public int? Foo { get; set; }
+            
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_non_scalar_parameter_has_a_converter_that_derives_from_a_compatible_BindingConverter()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            public class MyConverter : BindingConverter<string>
+            {
+                public override string Convert(string rawValue) => rawValue;
+            }
+            
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0, Converter = typeof(MyConverter))]
+                public IReadOnlyList<string> Foo { get; set; }
+            
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -61,15 +144,17 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
+        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);
@@ -80,17 +165,18 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
+        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,55 +2,85 @@
 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_if_one_of_the_specified_parameter_validators_does_not_derive_from_BindingValidator()
+    public void Analyzer_reports_an_error_a_parameter_has_a_validator_that_does_not_derive_from_BindingValidator()
     {
         // Arrange
         // language=cs
-            const string code = @"
-public class MyValidator
-{
+        const string code =
+            """
+            public class MyValidator
+            {
                 public void Validate(string value) {}
-}
+            }
             
-[Command]
-public class MyCommand : ICommand
-{
+            [Command]
+            public class MyCommand : ICommand
+            {
                 [CommandParameter(0, Validators = new[] {typeof(MyValidator)})]
                 public string Foo { get; set; }
             
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
     }
 
     [Fact]
-        public void Analyzer_does_not_report_an_error_if_all_specified_parameter_validators_derive_from_BindingValidator()
+    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<string>
-{
-    public override BindingValidationError Validate(string value) => Ok();
-}
+        const string code =
+            """
+            public class MyValidator : BindingValidator<int>
+            {
+                public override BindingValidationError Validate(int value) => Ok();
+            }
             
-[Command]
-public class MyCommand : ICommand
-{
+            [Command]
+            public class MyCommand : ICommand
+            {
                 [CommandParameter(0, Validators = new[] {typeof(MyValidator)})]
                 public string Foo { get; set; }
             
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_parameter_has_validators_that_all_derive_from_compatible_BindingValidators()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            public class MyValidator : BindingValidator<string>
+            {
+                public override BindingValidationError Validate(string value) => Ok();
+            }
+            
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0, Validators = new[] {typeof(MyValidator)})]
+                public string Foo { get; set; }
+            
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -61,15 +91,17 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
+        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);
@@ -80,17 +112,18 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
+        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,10 +2,10 @@
 using Microsoft.CodeAnalysis.Diagnostics;
 using Xunit;
 
-namespace CliFx.Analyzers.Tests
+namespace CliFx.Analyzers.Tests;
+
+public class SystemConsoleShouldBeAvoidedAnalyzerSpecs
 {
-    public class SystemConsoleShouldBeAvoidedAnalyzerSpecs
-    {
     private static DiagnosticAnalyzer Analyzer { get; } = new SystemConsoleShouldBeAvoidedAnalyzer();
 
     [Fact]
@@ -13,16 +13,18 @@ namespace CliFx.Analyzers.Tests
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
                 public ValueTask ExecuteAsync(IConsole console)
                 {
-        Console.WriteLine(""Hello world"");
+                    Console.WriteLine("Hello world");
                     return default;
                 }
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -33,16 +35,19 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
                 public ValueTask ExecuteAsync(IConsole console)
                 {
                     Console.ForegroundColor = ConsoleColor.Black;
                     return default;
                 }
-}";
+            }
+            """;
+
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
     }
@@ -52,16 +57,18 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
                 public ValueTask ExecuteAsync(IConsole console)
                 {
-        Console.Error.WriteLine(""Hello world"");
+                    Console.Error.WriteLine("Hello world");
                     return default;
                 }
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -72,16 +79,18 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
                 public ValueTask ExecuteAsync(IConsole console)
                 {
-        console.Output.WriteLine(""Hello world"");
+                    console.Output.WriteLine("Hello world");
                     return default;
                 }
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -92,17 +101,39 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-            const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    public void SomeOtherMethod() => Console.WriteLine(""Test"");
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public void SomeOtherMethod() => Console.WriteLine("Test");
             
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
     }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_command_does_not_access_SystemConsole()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    return default;
+                }
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
     }
 }

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,10 +11,10 @@ using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Text;
 
-namespace CliFx.Analyzers.Tests.Utils
+namespace CliFx.Analyzers.Tests.Utils;
+
+internal class AnalyzerAssertions : ReferenceTypeAssertions<DiagnosticAnalyzer, AnalyzerAssertions>
 {
-    internal class AnalyzerAssertions : ReferenceTypeAssertions<DiagnosticAnalyzer, AnalyzerAssertions>
-    {
     protected override string Identifier { get; } = "analyzer";
 
     public AnalyzerAssertions(DiagnosticAnalyzer analyzer)
@@ -57,15 +57,9 @@ namespace CliFx.Analyzers.Tests.Utils
         // 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)
-                },
+            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)
         );
@@ -78,9 +72,10 @@ namespace CliFx.Analyzers.Tests.Utils
         if (compilationErrors.Any())
         {
             throw new InvalidOperationException(
-                    "Failed to compile code." +
-                    Environment.NewLine +
-                    string.Join(Environment.NewLine, compilationErrors.Select(e => e.ToString()))
+                $"""
+                Failed to compile code.
+                {string.Join(Environment.NewLine, compilationErrors.Select(e => e.ToString()))}
+                """
             );
         }
 
@@ -107,11 +102,11 @@ namespace CliFx.Analyzers.Tests.Utils
         var expectedDiagnosticIds = expectedDiagnostics.Select(d => d.Id).Distinct().ToArray();
         var producedDiagnosticIds = producedDiagnostics.Select(d => d.Id).Distinct().ToArray();
 
-            var result =
+        var isSuccessfulAssertion =
             expectedDiagnosticIds.Intersect(producedDiagnosticIds).Count() ==
             expectedDiagnosticIds.Length;
 
-            Execute.Assertion.ForCondition(result).FailWith(() =>
+        Execute.Assertion.ForCondition(isSuccessfulAssertion).FailWith(() =>
         {
             var buffer = new StringBuilder();
 
@@ -131,11 +126,18 @@ namespace CliFx.Analyzers.Tests.Utils
 
             buffer.AppendLine("Produced diagnostics:");
 
+            if (producedDiagnostics.Any())
+            {
                 foreach (var producedDiagnostic in producedDiagnostics)
                 {
                     buffer.Append("  - ");
                     buffer.Append(producedDiagnostic);
                 }
+            }
+            else
+            {
+                buffer.AppendLine("  < none >");
+            }
 
             return new FailReason(buffer.ToString());
         });
@@ -144,10 +146,9 @@ namespace CliFx.Analyzers.Tests.Utils
     public void NotProduceDiagnostics(string sourceCode)
     {
         var producedDiagnostics = GetProducedDiagnostics(sourceCode);
+        var isSuccessfulAssertion = !producedDiagnostics.Any();
 
-            var result = !producedDiagnostics.Any();
-
-            Execute.Assertion.ForCondition(result).FailWith(() =>
+        Execute.Assertion.ForCondition(isSuccessfulAssertion).FailWith(() =>
         {
             var buffer = new StringBuilder();
 
@@ -165,10 +166,9 @@ namespace CliFx.Analyzers.Tests.Utils
             return new FailReason(buffer.ToString());
         });
     }
-    }
-
-    internal static class AnalyzerAssertionsExtensions
-    {
-        public static AnalyzerAssertions Should(this DiagnosticAnalyzer analyzer) => new(analyzer);
-    }
+}
+
+internal static class AnalyzerAssertionsExtensions
+{
+    public static AnalyzerAssertions Should(this DiagnosticAnalyzer analyzer) => new(analyzer);
 }

CliFx.Analyzers/AnalyzerBase.cs

@@ -3,10 +3,10 @@ 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; }
@@ -28,13 +28,12 @@ namespace CliFx.Analyzers
         SupportedDiagnostics = ImmutableArray.Create(SupportedDiagnostic);
     }
 
-        protected Diagnostic CreateDiagnostic(Location location) =>
-            Diagnostic.Create(SupportedDiagnostic, location);
+    protected Diagnostic CreateDiagnostic(Location location, params object?[]? messageArgs) =>
+        Diagnostic.Create(SupportedDiagnostic, location, messageArgs);
 
     public override void Initialize(AnalysisContext context)
     {
         context.EnableConcurrentExecution();
         context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
     }
-    }
 }

CliFx.Analyzers/CliFx.Analyzers.csproj

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

CliFx.Analyzers/CommandMustBeAnnotatedAnalyzer.cs

@@ -5,11 +5,11 @@ 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}`",
@@ -30,18 +30,20 @@ namespace CliFx.Analyzers
 
         var implementsCommandInterface = type
             .AllInterfaces
-                .Any(s => s.DisplayNameMatches(SymbolNames.CliFxCommandInterface));
+            .Any(i => i.DisplayNameMatches(SymbolNames.CliFxCommandInterface));
 
         var hasCommandAttribute = type
             .GetAttributes()
             .Select(a => a.AttributeClass)
-                .Any(s => s.DisplayNameMatches(SymbolNames.CliFxCommandAttribute));
+            .Any(c => c.DisplayNameMatches(SymbolNames.CliFxCommandAttribute));
 
         // If the interface is implemented, but the attribute is missing,
         // then it's very likely a user error.
         if (implementsCommandInterface && !hasCommandAttribute)
         {
-                context.ReportDiagnostic(CreateDiagnostic(classDeclaration.GetLocation()));
+            context.ReportDiagnostic(
+                CreateDiagnostic(classDeclaration.Identifier.GetLocation())
+            );
         }
     }
 
@@ -50,5 +52,4 @@ namespace CliFx.Analyzers
         base.Initialize(context);
         context.HandleClassDeclaration(Analyze);
     }
-    }
 }

CliFx.Analyzers/CommandMustImplementInterfaceAnalyzer.cs

@@ -5,11 +5,11 @@ 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",
@@ -25,17 +25,19 @@ namespace CliFx.Analyzers
         var hasCommandAttribute = type
             .GetAttributes()
             .Select(a => a.AttributeClass)
-                .Any(s => s.DisplayNameMatches(SymbolNames.CliFxCommandAttribute));
+            .Any(c => c.DisplayNameMatches(SymbolNames.CliFxCommandAttribute));
 
         var implementsCommandInterface = type
             .AllInterfaces
-                .Any(s => s.DisplayNameMatches(SymbolNames.CliFxCommandInterface));
+            .Any(i => i.DisplayNameMatches(SymbolNames.CliFxCommandInterface));
 
         // If the attribute is present, but the interface is not implemented,
         // it's very likely a user error.
         if (hasCommandAttribute && !implementsCommandInterface)
         {
-                context.ReportDiagnostic(CreateDiagnostic(classDeclaration.GetLocation()));
+            context.ReportDiagnostic(
+                CreateDiagnostic(classDeclaration.Identifier.GetLocation())
+            );
         }
     }
 
@@ -44,5 +46,4 @@ namespace CliFx.Analyzers
         base.Initialize(context);
         context.HandleClassDeclaration(Analyze);
     }
-    }
 }

CliFx.Analyzers/ObjectModel/CommandOptionSymbol.cs

@@ -1,54 +1,71 @@
 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)
     {
+        Property = property;
         Name = name;
         ShortName = shortName;
+        IsRequired = isRequired;
         ConverterType = converterType;
         ValidatorTypes = validatorTypes;
     }
-    }
+}
 
-    internal partial class CommandOptionSymbol
-    {
-        private static AttributeData? TryGetOptionAttribute(IPropertySymbol property) =>
-            property
+internal partial class CommandOptionSymbol
+{
+    private static AttributeData? TryGetOptionAttribute(IPropertySymbol property) => property
         .GetAttributes()
-                .FirstOrDefault(a => a.AttributeClass.DisplayNameMatches(SymbolNames.CliFxCommandOptionAttribute));
+        .FirstOrDefault(a => a.AttributeClass?.DisplayNameMatches(SymbolNames.CliFxCommandOptionAttribute) == true);
 
-        private static CommandOptionSymbol FromAttribute(AttributeData attribute)
+    public static CommandOptionSymbol? TryResolve(IPropertySymbol property)
     {
+        var attribute = TryGetOptionAttribute(property);
+        if (attribute is null)
+            return null;
+
         var name = attribute
             .ConstructorArguments
-                .Where(a => a.Type.DisplayNameMatches("string") || a.Type.DisplayNameMatches("System.String"))
+            .Where(a => a.Type?.SpecialType == SpecialType.System_String)
             .Select(a => a.Value)
             .FirstOrDefault() as string;
 
         var shortName = attribute
             .ConstructorArguments
-                .Where(a => a.Type.DisplayNameMatches("char") || a.Type.DisplayNameMatches("System.Char"))
+            .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")
@@ -64,20 +81,9 @@ namespace CliFx.Analyzers.ObjectModel
             .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);
+        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,41 +3,52 @@ 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)
     {
+        Property = property;
         Order = order;
         Name = name;
+        IsRequired = isRequired;
         ConverterType = converterType;
         ValidatorTypes = validatorTypes;
     }
-    }
+}
 
-    internal partial class CommandParameterSymbol
-    {
-        private static AttributeData? TryGetParameterAttribute(IPropertySymbol property) =>
-            property
+internal partial class CommandParameterSymbol
+{
+    private static AttributeData? TryGetParameterAttribute(IPropertySymbol property) => property
         .GetAttributes()
-                .FirstOrDefault(a => a.AttributeClass.DisplayNameMatches(SymbolNames.CliFxCommandParameterAttribute));
+        .FirstOrDefault(a => a.AttributeClass?.DisplayNameMatches(SymbolNames.CliFxCommandParameterAttribute) == true);
 
-        private static CommandParameterSymbol FromAttribute(AttributeData attribute)
+    public static CommandParameterSymbol? TryResolve(IPropertySymbol property)
     {
-            var order = (int) attribute
+        var attribute = TryGetParameterAttribute(property);
+        if (attribute is null)
+            return null;
+
+        var order = (int)attribute
             .ConstructorArguments
             .Select(a => a.Value)
             .First()!;
@@ -48,6 +59,12 @@ namespace CliFx.Analyzers.ObjectModel
             .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")
@@ -63,20 +80,9 @@ namespace CliFx.Analyzers.ObjectModel
             .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);
+        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>";
-    }
 }

CliFx.Analyzers/OptionMustBeInsideCommandAnalyzer.cs

@@ -5,11 +5,11 @@ 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",
@@ -22,6 +22,9 @@ namespace CliFx.Analyzers
         PropertyDeclarationSyntax propertyDeclaration,
         IPropertySymbol property)
     {
+        if (property.ContainingType is null)
+            return;
+
         if (property.ContainingType.IsAbstract)
             return;
 
@@ -31,11 +34,13 @@ namespace CliFx.Analyzers
         var isInsideCommand = property
             .ContainingType
             .AllInterfaces
-                .Any(s => s.DisplayNameMatches(SymbolNames.CliFxCommandInterface));
+            .Any(i => i.DisplayNameMatches(SymbolNames.CliFxCommandInterface));
 
         if (!isInsideCommand)
         {
-                context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+            context.ReportDiagnostic(
+                CreateDiagnostic(propertyDeclaration.Identifier.GetLocation())
+            );
         }
     }
 
@@ -44,5 +49,4 @@ namespace CliFx.Analyzers
         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,11 +4,11 @@ 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",
@@ -27,7 +27,9 @@ namespace CliFx.Analyzers
 
         if (string.IsNullOrWhiteSpace(option.Name) && option.ShortName is null)
         {
-                context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+            context.ReportDiagnostic(
+                CreateDiagnostic(propertyDeclaration.Identifier.GetLocation())
+            );
         }
     }
 
@@ -36,5 +38,4 @@ namespace CliFx.Analyzers
         base.Initialize(context);
         context.HandlePropertyDeclaration(Analyze);
     }
-    }
 }

CliFx.Analyzers/OptionMustHaveUniqueNameAnalyzer.cs

@@ -6,15 +6,17 @@ 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).")
+            "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}`.")
     {
     }
 
@@ -23,6 +25,9 @@ namespace CliFx.Analyzers
         PropertyDeclarationSyntax propertyDeclaration,
         IPropertySymbol property)
     {
+        if (property.ContainingType is null)
+            return;
+
         var option = CommandOptionSymbol.TryResolve(property);
         if (option is null)
             return;
@@ -34,7 +39,7 @@ namespace CliFx.Analyzers
             .ContainingType
             .GetMembers()
             .OfType<IPropertySymbol>()
-                .Where(m => !m.Equals(property, SymbolEqualityComparer.Default))
+            .Where(m => !m.Equals(property))
             .ToArray();
 
         foreach (var otherProperty in otherProperties)
@@ -48,7 +53,13 @@ namespace CliFx.Analyzers
 
             if (string.Equals(option.Name, otherOption.Name, StringComparison.OrdinalIgnoreCase))
             {
-                    context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+                context.ReportDiagnostic(
+                    CreateDiagnostic(
+                        propertyDeclaration.Identifier.GetLocation(),
+                        option.Name,
+                        otherProperty.Name
+                    )
+                );
             }
         }
     }
@@ -58,5 +69,4 @@ namespace CliFx.Analyzers
         base.Initialize(context);
         context.HandlePropertyDeclaration(Analyze);
     }
-    }
 }

CliFx.Analyzers/OptionMustHaveUniqueShortNameAnalyzer.cs

@@ -5,15 +5,17 @@ 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).")
+            "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}`.")
     {
     }
 
@@ -22,6 +24,9 @@ namespace CliFx.Analyzers
         PropertyDeclarationSyntax propertyDeclaration,
         IPropertySymbol property)
     {
+        if (property.ContainingType is null)
+            return;
+
         var option = CommandOptionSymbol.TryResolve(property);
         if (option is null)
             return;
@@ -33,7 +38,7 @@ namespace CliFx.Analyzers
             .ContainingType
             .GetMembers()
             .OfType<IPropertySymbol>()
-                .Where(m => !m.Equals(property, SymbolEqualityComparer.Default))
+            .Where(m => !m.Equals(property))
             .ToArray();
 
         foreach (var otherProperty in otherProperties)
@@ -47,7 +52,13 @@ namespace CliFx.Analyzers
 
             if (option.ShortName == otherOption.ShortName)
             {
-                    context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+                context.ReportDiagnostic(
+                    CreateDiagnostic(
+                        propertyDeclaration.Identifier.GetLocation(),
+                        option.ShortName,
+                        otherProperty.Name
+                    )
+                );
             }
         }
     }
@@ -57,5 +68,4 @@ namespace CliFx.Analyzers
         base.Initialize(context);
         context.HandlePropertyDeclaration(Analyze);
     }
-    }
 }

CliFx.Analyzers/OptionMustHaveValidConverterAnalyzer.cs

@@ -5,15 +5,15 @@ 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 `{SymbolNames.CliFxBindingConverterClass}`.")
+            $"Converter specified for this option must derive from a compatible `{SymbolNames.CliFxBindingConverterClass}`.")
     {
     }
 
@@ -29,15 +29,28 @@ namespace CliFx.Analyzers
         if (option.ConverterType is null)
             return;
 
-            // We check against an internal interface because checking against a generic class is a pain
-            var converterImplementsInterface = option
+        var converterValueType = option
             .ConverterType
-                .AllInterfaces
-                .Any(s => s.DisplayNameMatches(SymbolNames.CliFxBindingConverterInterface));
+            .GetBaseTypes()
+            .FirstOrDefault(t => t.ConstructedFrom.DisplayNameMatches(SymbolNames.CliFxBindingConverterClass))?
+            .TypeArguments
+            .FirstOrDefault();
 
-            if (!converterImplementsInterface)
+        // Value returned by the converter must be assignable to the property type
+        var isCompatible =
+            converterValueType is not null && (option.IsScalar()
+                // Scalar
+                ? context.Compilation.IsAssignable(converterValueType, property.Type)
+                // Non-scalar (assume we can handle all IEnumerable types for simplicity)
+                : property.Type.TryGetEnumerableUnderlyingType() is { } enumerableUnderlyingType &&
+                  context.Compilation.IsAssignable(converterValueType, enumerableUnderlyingType)
+            );
+
+        if (!isCompatible)
         {
-                context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+            context.ReportDiagnostic(
+                CreateDiagnostic(propertyDeclaration.Identifier.GetLocation())
+            );
         }
     }
 
@@ -46,5 +59,4 @@ namespace CliFx.Analyzers
         base.Initialize(context);
         context.HandlePropertyDeclaration(Analyze);
     }
-    }
 }

CliFx.Analyzers/OptionMustHaveValidNameAnalyzer.cs

@@ -4,15 +4,16 @@ 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.")
+            "This option's name must be at least 2 characters long and must start with a letter. " +
+            "Specified name: `{0}`.")
     {
     }
 
@@ -30,7 +31,12 @@ namespace CliFx.Analyzers
 
         if (option.Name.Length < 2 || !char.IsLetter(option.Name[0]))
         {
-                context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+            context.ReportDiagnostic(
+                CreateDiagnostic(
+                    propertyDeclaration.Identifier.GetLocation(),
+                    option.Name
+                )
+            );
         }
     }
 
@@ -39,5 +45,4 @@ namespace CliFx.Analyzers
         base.Initialize(context);
         context.HandlePropertyDeclaration(Analyze);
     }
-    }
 }

CliFx.Analyzers/OptionMustHaveValidShortNameAnalyzer.cs

@@ -4,15 +4,16 @@ 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.")
+            "This option's short name must be a single letter character. " +
+            "Specified short name: `{0}`.")
     {
     }
 
@@ -30,7 +31,12 @@ namespace CliFx.Analyzers
 
         if (!char.IsLetter(option.ShortName.Value))
         {
-                context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+            context.ReportDiagnostic(
+                CreateDiagnostic(
+                    propertyDeclaration.Identifier.GetLocation(),
+                    option.ShortName
+                )
+            );
         }
     }
 
@@ -39,5 +45,4 @@ namespace CliFx.Analyzers
         base.Initialize(context);
         context.HandlePropertyDeclaration(Analyze);
     }
-    }
 }

CliFx.Analyzers/OptionMustHaveValidValidatorsAnalyzer.cs

@@ -5,15 +5,15 @@ 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}`",
-                $"All validators specified for this option must derive from `{SymbolNames.CliFxBindingValidatorClass}`.")
+            $"Each validator specified for this option must derive from a compatible `{SymbolNames.CliFxBindingValidatorClass}`.")
     {
     }
 
@@ -28,14 +28,22 @@ namespace CliFx.Analyzers
 
         foreach (var validatorType in option.ValidatorTypes)
         {
-                // We check against an internal interface because checking against a generic class is a pain
-                var validatorImplementsInterface = validatorType
-                    .AllInterfaces
-                    .Any(s => s.DisplayNameMatches(SymbolNames.CliFxBindingValidatorInterface));
+            var validatorValueType = validatorType
+                .GetBaseTypes()
+                .FirstOrDefault(t => t.ConstructedFrom.DisplayNameMatches(SymbolNames.CliFxBindingValidatorClass))?
+                .TypeArguments
+                .FirstOrDefault();
 
-                if (!validatorImplementsInterface)
+            // Value passed to the validator must be assignable from the property type
+            var isCompatible =
+                validatorValueType is not null &&
+                context.Compilation.IsAssignable(property.Type, validatorValueType);
+
+            if (!isCompatible)
             {
-                    context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+                context.ReportDiagnostic(
+                    CreateDiagnostic(propertyDeclaration.Identifier.GetLocation())
+                );
 
                 // No need to report multiple identical diagnostics on the same node
                 break;
@@ -48,5 +56,4 @@ namespace CliFx.Analyzers
         base.Initialize(context);
         context.HandlePropertyDeclaration(Analyze);
     }
-    }
 }

CliFx.Analyzers/ParameterMustBeInsideCommandAnalyzer.cs

@@ -5,11 +5,11 @@ 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",
@@ -22,6 +22,9 @@ namespace CliFx.Analyzers
         PropertyDeclarationSyntax propertyDeclaration,
         IPropertySymbol property)
     {
+        if (property.ContainingType is null)
+            return;
+
         if (property.ContainingType.IsAbstract)
             return;
 
@@ -31,11 +34,13 @@ namespace CliFx.Analyzers
         var isInsideCommand = property
             .ContainingType
             .AllInterfaces
-                .Any(s => s.DisplayNameMatches(SymbolNames.CliFxCommandInterface));
+            .Any(i => i.DisplayNameMatches(SymbolNames.CliFxCommandInterface));
 
         if (!isInsideCommand)
         {
-                context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+            context.ReportDiagnostic(
+                CreateDiagnostic(propertyDeclaration.Identifier.GetLocation())
+            );
         }
     }
 
@@ -44,5 +49,4 @@ namespace CliFx.Analyzers
         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))
+            .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,42 +5,39 @@ 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 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).")
+            "Parameters of non-scalar types must be the last in order",
+            "This parameter has a non-scalar type so it must be the last in order (its order must be highest within the command). " +
+            "Property bound to another non-scalar parameter: `{0}`.")
     {
     }
 
-        private static bool IsScalar(ITypeSymbol type) =>
-            type.DisplayNameMatches("string") ||
-            type.DisplayNameMatches("System.String") ||
-            !type.AllInterfaces
-                .Select(i => i.ConstructedFrom)
-                .Any(s => s.DisplayNameMatches("System.Collections.Generic.IEnumerable<T>"));
-
     private void Analyze(
         SyntaxNodeAnalysisContext context,
         PropertyDeclarationSyntax propertyDeclaration,
         IPropertySymbol property)
     {
-            if (IsScalar(property.Type))
+        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))
+            .Where(m => !m.Equals(property))
             .ToArray();
 
         foreach (var otherProperty in otherProperties)
@@ -51,7 +48,12 @@ namespace CliFx.Analyzers
 
             if (otherParameter.Order > parameter.Order)
             {
-                    context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+                context.ReportDiagnostic(
+                    CreateDiagnostic(
+                        propertyDeclaration.Identifier.GetLocation(),
+                        otherProperty.Name
+                    )
+                );
             }
         }
     }
@@ -61,5 +63,4 @@ namespace CliFx.Analyzers
         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))
+            .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,51 +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 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.")
+            "This parameter has a non-scalar type so it must be the only such parameter in the command. " +
+            "Property bound to another non-scalar parameter: `{0}`.")
     {
     }
 
-        private static bool IsScalar(ITypeSymbol type) =>
-            type.DisplayNameMatches("string") ||
-            type.DisplayNameMatches("System.String") ||
-            !type.AllInterfaces
-                .Select(i => i.ConstructedFrom)
-                .Any(s => s.DisplayNameMatches("System.Collections.Generic.IEnumerable<T>"));
-
     private void Analyze(
         SyntaxNodeAnalysisContext context,
         PropertyDeclarationSyntax propertyDeclaration,
         IPropertySymbol property)
     {
-            if (!CommandParameterSymbol.IsParameterProperty(property))
+        if (property.ContainingType is null)
             return;
 
-            if (IsScalar(property.Type))
+        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))
+            .Where(m => !m.Equals(property))
             .ToArray();
 
         foreach (var otherProperty in otherProperties)
         {
-                if (!CommandParameterSymbol.IsParameterProperty(otherProperty))
+            var otherParameter = CommandParameterSymbol.TryResolve(otherProperty);
+            if (otherParameter is null)
                 continue;
 
-                if (!IsScalar(otherProperty.Type))
+            if (!otherParameter.IsScalar())
             {
-                    context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+                context.ReportDiagnostic(
+                    CreateDiagnostic(
+                        propertyDeclaration.Identifier.GetLocation(),
+                        otherProperty.Name
+                    )
+                );
             }
         }
     }
@@ -59,5 +63,4 @@ namespace CliFx.Analyzers
         base.Initialize(context);
         context.HandlePropertyDeclaration(Analyze);
     }
-    }
 }

CliFx.Analyzers/ParameterMustHaveUniqueNameAnalyzer.cs

@@ -6,15 +6,17 @@ 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).")
+            "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}`.")
     {
     }
 
@@ -23,6 +25,9 @@ namespace CliFx.Analyzers
         PropertyDeclarationSyntax propertyDeclaration,
         IPropertySymbol property)
     {
+        if (property.ContainingType is null)
+            return;
+
         var parameter = CommandParameterSymbol.TryResolve(property);
         if (parameter is null)
             return;
@@ -34,7 +39,7 @@ namespace CliFx.Analyzers
             .ContainingType
             .GetMembers()
             .OfType<IPropertySymbol>()
-                .Where(m => !m.Equals(property, SymbolEqualityComparer.Default))
+            .Where(m => !m.Equals(property))
             .ToArray();
 
         foreach (var otherProperty in otherProperties)
@@ -48,7 +53,13 @@ namespace CliFx.Analyzers
 
             if (string.Equals(parameter.Name, otherParameter.Name, StringComparison.OrdinalIgnoreCase))
             {
-                    context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+                context.ReportDiagnostic(
+                    CreateDiagnostic(
+                        propertyDeclaration.Identifier.GetLocation(),
+                        parameter.Name,
+                        otherProperty.Name
+                    )
+                );
             }
         }
     }
@@ -58,5 +69,4 @@ namespace CliFx.Analyzers
         base.Initialize(context);
         context.HandlePropertyDeclaration(Analyze);
     }
-    }
 }

CliFx.Analyzers/ParameterMustHaveUniqueOrderAnalyzer.cs

@@ -5,15 +5,17 @@ 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.")
+            "This parameter's order must be unique within the command. " +
+            "Specified order: {0}. " +
+            "Property bound to another parameter with the same order: `{1}`.")
     {
     }
 
@@ -22,6 +24,9 @@ namespace CliFx.Analyzers
         PropertyDeclarationSyntax propertyDeclaration,
         IPropertySymbol property)
     {
+        if (property.ContainingType is null)
+            return;
+
         var parameter = CommandParameterSymbol.TryResolve(property);
         if (parameter is null)
             return;
@@ -30,7 +35,7 @@ namespace CliFx.Analyzers
             .ContainingType
             .GetMembers()
             .OfType<IPropertySymbol>()
-                .Where(m => !m.Equals(property, SymbolEqualityComparer.Default))
+            .Where(m => !m.Equals(property))
             .ToArray();
 
         foreach (var otherProperty in otherProperties)
@@ -41,7 +46,13 @@ namespace CliFx.Analyzers
 
             if (parameter.Order == otherParameter.Order)
             {
-                    context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+                context.ReportDiagnostic(
+                    CreateDiagnostic(
+                        propertyDeclaration.Identifier.GetLocation(),
+                        parameter.Order,
+                        otherProperty.Name
+                    )
+                );
             }
         }
     }
@@ -51,5 +62,4 @@ namespace CliFx.Analyzers
         base.Initialize(context);
         context.HandlePropertyDeclaration(Analyze);
     }
-    }
 }

CliFx.Analyzers/ParameterMustHaveValidConverterAnalyzer.cs

@@ -5,15 +5,15 @@ 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 `{SymbolNames.CliFxBindingConverterClass}`.")
+            $"Converter specified for this parameter must derive from a compatible `{SymbolNames.CliFxBindingConverterClass}`.")
     {
     }
 
@@ -29,15 +29,28 @@ namespace CliFx.Analyzers
         if (parameter.ConverterType is null)
             return;
 
-            // We check against an internal interface because checking against a generic class is a pain
-            var converterImplementsInterface = parameter
+        var converterValueType = parameter
             .ConverterType
-                .AllInterfaces
-                .Any(s => s.DisplayNameMatches(SymbolNames.CliFxBindingConverterInterface));
+            .GetBaseTypes()
+            .FirstOrDefault(t => t.ConstructedFrom.DisplayNameMatches(SymbolNames.CliFxBindingConverterClass))?
+            .TypeArguments
+            .FirstOrDefault();
 
-            if (!converterImplementsInterface)
+        // Value returned by the converter must be assignable to the property type
+        var isCompatible =
+            converterValueType is not null && (parameter.IsScalar()
+                // Scalar
+                ? context.Compilation.IsAssignable(converterValueType, property.Type)
+                // Non-scalar (assume we can handle all IEnumerable types for simplicity)
+                : property.Type.TryGetEnumerableUnderlyingType() is { } enumerableUnderlyingType &&
+                  context.Compilation.IsAssignable(converterValueType, enumerableUnderlyingType)
+            );
+
+        if (!isCompatible)
         {
-                context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+            context.ReportDiagnostic(
+                CreateDiagnostic(propertyDeclaration.Identifier.GetLocation())
+            );
         }
     }
 
@@ -46,5 +59,4 @@ namespace CliFx.Analyzers
         base.Initialize(context);
         context.HandlePropertyDeclaration(Analyze);
     }
-    }
 }

CliFx.Analyzers/ParameterMustHaveValidValidatorsAnalyzer.cs

@@ -5,15 +5,15 @@ 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}`",
-                $"All validators specified for this parameter must derive from `{SymbolNames.CliFxBindingValidatorClass}`.")
+            $"Each validator specified for this parameter must derive from a compatible `{SymbolNames.CliFxBindingValidatorClass}`.")
     {
     }
 
@@ -28,14 +28,22 @@ namespace CliFx.Analyzers
 
         foreach (var validatorType in parameter.ValidatorTypes)
         {
-                // We check against an internal interface because checking against a generic class is a pain
-                var validatorImplementsInterface = validatorType
-                    .AllInterfaces
-                    .Any(s => s.DisplayNameMatches(SymbolNames.CliFxBindingValidatorInterface));
+            var validatorValueType = validatorType
+                .GetBaseTypes()
+                .FirstOrDefault(t => t.ConstructedFrom.DisplayNameMatches(SymbolNames.CliFxBindingValidatorClass))?
+                .TypeArguments
+                .FirstOrDefault();
 
-                if (!validatorImplementsInterface)
+            // Value passed to the validator must be assignable from the property type
+            var isCompatible =
+                validatorValueType is not null &&
+                context.Compilation.IsAssignable(property.Type, validatorValueType);
+
+            if (!isCompatible)
             {
-                    context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+                context.ReportDiagnostic(
+                    CreateDiagnostic(propertyDeclaration.Identifier.GetLocation())
+                );
 
                 // No need to report multiple identical diagnostics on the same node
                 break;
@@ -48,5 +56,4 @@ namespace CliFx.Analyzers
         base.Initialize(context);
         context.HandlePropertyDeclaration(Analyze);
     }
-    }
 }

CliFx.Analyzers/SystemConsoleShouldBeAvoidedAnalyzer.cs

@@ -6,11 +6,11 @@ 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",
@@ -27,9 +27,9 @@ namespace CliFx.Analyzers
 
         while (currentNode is MemberAccessExpressionSyntax memberAccess)
         {
-                var symbol = context.SemanticModel.GetSymbolInfo(memberAccess).Symbol;
+            var member = context.SemanticModel.GetSymbolInfo(memberAccess).Symbol;
 
-                if (symbol is not null && symbol.ContainingType.DisplayNameMatches("System.Console"))
+            if (member?.ContainingType?.DisplayNameMatches("System.Console") == true)
             {
                 return memberAccess;
             }
@@ -53,7 +53,8 @@ namespace CliFx.Analyzers
             return;
 
         // Check if IConsole is available in scope as an alternative to System.Console
-            var isConsoleInterfaceAvailable = context.Node
+        var isConsoleInterfaceAvailable = context
+            .Node
             .Ancestors()
             .OfType<MethodDeclarationSyntax>()
             .SelectMany(m => m.ParameterList.Parameters)
@@ -64,7 +65,9 @@ namespace CliFx.Analyzers
 
         if (isConsoleInterfaceAvailable)
         {
-                context.ReportDiagnostic(CreateDiagnostic(systemConsoleMemberAccess.GetLocation()));
+            context.ReportDiagnostic(
+                CreateDiagnostic(systemConsoleMemberAccess.GetLocation())
+            );
         }
     }
 
@@ -73,5 +76,4 @@ namespace CliFx.Analyzers
         base.Initialize(context);
         context.RegisterSyntaxNodeAction(Analyze, SyntaxKind.SimpleMemberAccessExpression);
     }
-    }
 }

CliFx.Analyzers/Utils/Extensions/RoslynExtensions.cs

@@ -1,19 +1,56 @@
 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(symbol.ToDisplayString(), name, StringComparison.Ordinal);
+        string.Equals(
+            // Fully qualified name, without `global::`
+            symbol.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat),
+            name,
+            StringComparison.Ordinal
+        );
+
+    public static IEnumerable<INamedTypeSymbol> GetBaseTypes(this ITypeSymbol type)
+    {
+        var current = type.BaseType;
+
+        while (current is not null)
+        {
+            yield return current;
+            current = current.BaseType;
+        }
+    }
+
+    public static ITypeSymbol? TryGetEnumerableUnderlyingType(this ITypeSymbol type) => type
+        .AllInterfaces
+        .FirstOrDefault(i => i.ConstructedFrom.SpecialType == SpecialType.System_Collections_Generic_IEnumerable_T)?
+        .TypeArguments[0];
+
+    // Detect if the property is required through roundabout means so as to not have to take dependency
+    // on higher versions of the C# compiler.
+    public static bool IsRequired(this IPropertySymbol property) => property
+        // Can't rely on the RequiredMemberAttribute because it's generated by the compiler, not added by the user,
+        // so we have to check for the presence of the `required` modifier in the syntax tree instead.
+        .DeclaringSyntaxReferences
+        .Select(r => r.GetSyntax())
+        .OfType<PropertyDeclarationSyntax>()
+        .SelectMany(p => p.Modifiers)
+        .Any(m => m.IsKind((SyntaxKind)8447));
+
+    public static bool IsAssignable(this Compilation compilation, ITypeSymbol source, ITypeSymbol destination) =>
+        compilation.ClassifyConversion(source, destination).Exists;
 
     public static void HandleClassDeclaration(
         this AnalysisContext analysisContext,
-            Action<SyntaxNodeAnalysisContext, ClassDeclarationSyntax, ITypeSymbol> handler)
+        Action<SyntaxNodeAnalysisContext, ClassDeclarationSyntax, ITypeSymbol> analyze)
     {
         analysisContext.RegisterSyntaxNodeAction(ctx =>
         {
@@ -24,13 +61,13 @@ namespace CliFx.Analyzers.Utils.Extensions
             if (type is null)
                 return;
 
-                handler(ctx, classDeclaration, type);
+            analyze(ctx, classDeclaration, type);
         }, SyntaxKind.ClassDeclaration);
     }
 
     public static void HandlePropertyDeclaration(
         this AnalysisContext analysisContext,
-            Action<SyntaxNodeAnalysisContext, PropertyDeclarationSyntax, IPropertySymbol> handler)
+        Action<SyntaxNodeAnalysisContext, PropertyDeclarationSyntax, IPropertySymbol> analyze)
     {
         analysisContext.RegisterSyntaxNodeAction(ctx =>
         {
@@ -41,8 +78,7 @@ namespace CliFx.Analyzers.Utils.Extensions
             if (property is null)
                 return;
 
-                handler(ctx, propertyDeclaration, property);
+            analyze(ctx, propertyDeclaration, property);
         }, SyntaxKind.PropertyDeclaration);
     }
-    }
 }

CliFx.Analyzers/Utils/Extensions/StringExtensions.cs

@@ -1,18 +1,17 @@
 using System;
 
-namespace CliFx.Analyzers.Utils.Extensions
+namespace CliFx.Analyzers.Utils.Extensions;
+
+internal static class StringExtensions
 {
-    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);
+            str = str[..^sub.Length];
 
         return str;
     }
-    }
 }

CliFx.Benchmarks/Benchmarks.CliFx.cs

@@ -4,10 +4,10 @@ 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
     {
@@ -29,5 +29,4 @@ namespace CliFx.Benchmarks
             .AddCommand<CliFxCommand>()
             .Build()
             .RunAsync(Arguments, new Dictionary<string, string>());
-    }
 }

CliFx.Benchmarks/Benchmarks.Clipr.cs

@@ -1,10 +1,10 @@
 using BenchmarkDotNet.Attributes;
 using clipr;
 
-namespace CliFx.Benchmarks
+namespace CliFx.Benchmarks;
+
+public partial class Benchmarks
 {
-    public partial class Benchmarks
-    {
     public class CliprCommand
     {
         [NamedArgument('s', "str")]
@@ -23,5 +23,4 @@ namespace CliFx.Benchmarks
 
     [Benchmark(Description = "Clipr")]
     public void ExecuteWithClipr() => CliParser.Parse<CliprCommand>(Arguments).Execute();
-    }
 }

CliFx.Benchmarks/Benchmarks.Cocona.cs

@@ -1,10 +1,10 @@
 using BenchmarkDotNet.Attributes;
 using Cocona;
 
-namespace CliFx.Benchmarks
+namespace CliFx.Benchmarks;
+
+public partial class Benchmarks
 {
-    public partial class Benchmarks
-    {
     public class CoconaCommand
     {
         public void Execute(
@@ -20,5 +20,4 @@ namespace CliFx.Benchmarks
 
     [Benchmark(Description = "Cocona")]
     public void ExecuteWithCocona() => CoconaApp.Run<CoconaCommand>(Arguments);
-    }
 }

CliFx.Benchmarks/Benchmarks.CommandLineParser.cs

@@ -1,10 +1,10 @@
 using BenchmarkDotNet.Attributes;
 using CommandLine;
 
-namespace CliFx.Benchmarks
+namespace CliFx.Benchmarks;
+
+public partial class Benchmarks
 {
-    public partial class Benchmarks
-    {
     public class CommandLineParserCommand
     {
         [Option('s', "str")]
@@ -26,5 +26,4 @@ namespace CliFx.Benchmarks
         new Parser()
             .ParseArguments(Arguments, typeof(CommandLineParserCommand))
             .WithParsed<CommandLineParserCommand>(c => c.Execute());
-    }
 }

CliFx.Benchmarks/Benchmarks.McMaster.cs

@@ -1,10 +1,10 @@
 using BenchmarkDotNet.Attributes;
 using McMaster.Extensions.CommandLineUtils;
 
-namespace CliFx.Benchmarks
+namespace CliFx.Benchmarks;
+
+public partial class Benchmarks
 {
-    public partial class Benchmarks
-    {
     public class McMasterCommand
     {
         [Option("--str|-s")]
@@ -21,5 +21,4 @@ namespace CliFx.Benchmarks
 
     [Benchmark(Description = "McMaster.Extensions.CommandLineUtils")]
     public int ExecuteWithMcMaster() => CommandLineApplication.Execute<McMasterCommand>(Arguments);
-    }
 }

CliFx.Benchmarks/Benchmarks.PowerArgs.cs

@@ -1,10 +1,10 @@
 using BenchmarkDotNet.Attributes;
 using PowerArgs;
 
-namespace CliFx.Benchmarks
+namespace CliFx.Benchmarks;
+
+public partial class Benchmarks
 {
-    public partial class Benchmarks
-    {
     public class PowerArgsCommand
     {
         [ArgShortcut("--str"), ArgShortcut("-s")]
@@ -23,5 +23,4 @@ namespace CliFx.Benchmarks
 
     [Benchmark(Description = "PowerArgs")]
     public void ExecuteWithPowerArgs() => Args.InvokeMain<PowerArgsCommand>(Arguments);
-    }
 }

CliFx.Benchmarks/Benchmarks.SystemCommandLine.cs

@@ -3,10 +3,10 @@ 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 static int ExecuteHandler(string s, int i, bool b) => 0;
@@ -40,5 +40,4 @@ namespace CliFx.Benchmarks
     [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
+namespace CliFx.Benchmarks;
+
+[RankColumn]
+[Orderer(SummaryOrderPolicy.FastestToSlowest)]
+public partial class Benchmarks
 {
-    [RankColumn]
-    [Orderer(SummaryOrderPolicy.FastestToSlowest)]
-    public partial class Benchmarks
-    {
     private static readonly string[] Arguments = {"--str", "hello world", "-i", "13", "-b"};
 
     public static void Main() => BenchmarkRunner.Run<Benchmarks>(
         DefaultConfig
             .Instance
-                .With(ConfigOptions.DisableOptimizationsValidator)
+            .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.5" />
     <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.2.0" />
+    <PackageReference Include="CommandLineParser" Version="2.9.1" />
+    <PackageReference Include="McMaster.Extensions.CommandLineUtils" Version="4.0.2" />
+    <PackageReference Include="PowerArgs" Version="4.0.2" />
     <PackageReference Include="System.CommandLine" Version="2.0.0-beta1.20574.7" />
   </ItemGroup>
 

CliFx.Demo/CliFx.Demo.csproj

@@ -2,17 +2,16 @@
 
   <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" />
   </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,18 +6,18 @@ 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 string Title { get; init; } = "";
+    public required string Title { get; init; }
 
     [CommandOption("author", 'a', IsRequired = true, Description = "Book author.")]
-        public string Author { get; init; } = "";
+    public required string Author { get; init; }
 
     [CommandOption("published", 'p', Description = "Book publish date.")]
     public DateTimeOffset Published { get; init; } = CreateRandomDate();
@@ -43,10 +43,10 @@ namespace CliFx.Demo.Commands
 
         return default;
     }
-    }
+}
 
-    public partial class BookAddCommand
-    {
+public partial class BookAddCommand
+{
     private static readonly Random Random = new();
 
     private static DateTimeOffset CreateRandomDate() => new(
@@ -66,5 +66,4 @@ namespace CliFx.Demo.Commands
         Random.Next(0, 99),
         Random.Next(0, 9)
     );
-    }
 }

CliFx.Demo/Commands/BookCommand.cs

@@ -5,15 +5,15 @@ 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 string Title { get; init; } = "";
+    public required string Title { get; init; }
 
     public BookCommand(LibraryProvider libraryProvider)
     {
@@ -31,5 +31,4 @@ namespace CliFx.Demo.Commands
 
         return default;
     }
-    }
 }

CliFx.Demo/Commands/BookListCommand.cs

@@ -4,11 +4,11 @@ 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)
@@ -33,5 +33,4 @@ namespace CliFx.Demo.Commands
 
         return default;
     }
-    }
 }

CliFx.Demo/Commands/BookRemoveCommand.cs

@@ -4,15 +4,15 @@ 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 string Title { get; init; } = "";
+    public required string Title { get; init; }
 
     public BookRemoveCommand(LibraryProvider libraryProvider)
     {
@@ -32,5 +32,4 @@ namespace CliFx.Demo.Commands
 
         return default;
     }
-    }
 }

CliFx.Demo/Domain/Book.cs

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

CliFx.Demo/Domain/Isbn.cs

@@ -1,34 +1,15 @@
 using System;
 
-namespace CliFx.Demo.Domain
+namespace CliFx.Demo.Domain;
+
+public partial record Isbn(int EanPrefix, int RegistrationGroup, int Registrant, int Publication, int CheckDigit)
 {
-    public partial class Isbn
-    {
-        public int EanPrefix { get; }
-
-        public int RegistrationGroup { get; }
-
-        public int Registrant { get; }
-
-        public int Publication { get; }
-
-        public int CheckDigit { get; }
-
-        public Isbn(int eanPrefix, int registrationGroup, int registrant, int publication, int checkDigit)
-        {
-            EanPrefix = eanPrefix;
-            RegistrationGroup = registrationGroup;
-            Registrant = registrant;
-            Publication = publication;
-            CheckDigit = checkDigit;
-        }
-
     public override string ToString() =>
         $"{EanPrefix:000}-{RegistrationGroup:00}-{Registrant:00000}-{Publication:00}-{CheckDigit:0}";
-    }
+}
 
-    public partial class Isbn
-    {
+public partial record Isbn
+{
     public static Isbn Parse(string value, IFormatProvider formatProvider)
     {
         var components = value.Split('-', 5, StringSplitOptions.RemoveEmptyEntries);
@@ -41,5 +22,4 @@ namespace CliFx.Demo.Domain
             int.Parse(components[4], formatProvider)
         );
     }
-    }
 }

CliFx.Demo/Domain/Library.cs

@@ -2,17 +2,10 @@
 using System.Collections.Generic;
 using System.Linq;
 
-namespace CliFx.Demo.Domain
+namespace CliFx.Demo.Domain;
+
+public partial record Library(IReadOnlyList<Book> Books)
 {
-    public partial class Library
-    {
-        public IReadOnlyList<Book> Books { get; }
-
-        public Library(IReadOnlyList<Book> books)
-        {
-            Books = books;
-        }
-
     public Library WithBook(Book book)
     {
         var books = Books.ToList();
@@ -27,10 +20,9 @@ namespace CliFx.Demo.Domain
 
         return new Library(books);
     }
-    }
-
-    public partial class Library
-    {
-        public static Library Empty { get; } = new(Array.Empty<Book>());
-    }
+}
+
+public partial record Library
+{
+    public static Library Empty { get; } = new(Array.Empty<Book>());
 }

CliFx.Demo/Domain/LibraryProvider.cs

@@ -1,16 +1,16 @@
 using System.IO;
 using System.Linq;
-using Newtonsoft.Json;
+using System.Text.Json;
 
-namespace CliFx.Demo.Domain
+namespace CliFx.Demo.Domain;
+
+public class LibraryProvider
 {
-    public class LibraryProvider
-    {
     private static string StorageFilePath { get; } = Path.Combine(Directory.GetCurrentDirectory(), "Library.json");
 
     private void StoreLibrary(Library library)
     {
-            var data = JsonConvert.SerializeObject(library);
+        var data = JsonSerializer.Serialize(library);
         File.WriteAllText(StorageFilePath, data);
     }
 
@@ -21,7 +21,7 @@ namespace CliFx.Demo.Domain
 
         var data = File.ReadAllText(StorageFilePath);
 
-            return JsonConvert.DeserializeObject<Library>(data);
+        return JsonSerializer.Deserialize<Library>(data) ?? Library.Empty;
     }
 
     public Book? TryGetBook(string title) => GetLibrary().Books.FirstOrDefault(b => b.Title == title);
@@ -37,5 +37,4 @@ namespace CliFx.Demo.Domain
         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()
+return await new CliApplicationBuilder()
     .SetDescription("Demo application showcasing CliFx features.")
     .AddCommandsFromThisAssembly()
-                .UseTypeActivator(GetServiceProvider().GetRequiredService)
+    .UseTypeActivator(serviceProvider.GetRequiredService)
     .Build()
     .RunAsync();
-    }
-}

CliFx.Demo/Readme.md

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

CliFx.Demo/Utils/ConsoleExtensions.cs

@@ -2,10 +2,10 @@
 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)
     {
         // Title
@@ -33,5 +33,4 @@ namespace CliFx.Demo.Utils
         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,11 +3,11 @@ 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)
     {
         var input = console.Input.ReadToEnd();
@@ -20,5 +20,4 @@ namespace CliFx.Tests.Dummy.Commands
 
         return default;
     }
-    }
 }

CliFx.Tests.Dummy/Commands/EnvironmentTestCommand.cs

@@ -2,11 +2,11 @@
 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";
 
@@ -16,5 +16,4 @@ namespace CliFx.Tests.Dummy.Commands
 
         return default;
     }
-    }
 }

CliFx.Tests.Dummy/Program.cs

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

CliFx.Tests/ApplicationSpecs.cs

@@ -6,10 +6,10 @@ 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)
     {
@@ -82,5 +82,4 @@ namespace CliFx.Tests
         exitCode.Should().NotBe(0);
         stdErr.Should().Contain("not a valid command");
     }
-    }
 }

CliFx.Tests/CancellationSpecs.cs

@@ -6,25 +6,25 @@ using FluentAssertions;
 using Xunit;
 using Xunit.Abstractions;
 
-namespace CliFx.Tests
+namespace CliFx.Tests;
+
+public class CancellationSpecs : SpecsBase
 {
-    public class CancellationSpecs : SpecsBase
-    {
     public CancellationSpecs(ITestOutputHelper testOutput)
         : base(testOutput)
     {
     }
 
     [Fact]
-        public async Task Command_can_register_to_receive_a_cancellation_signal_from_the_console()
+    public async Task Command_can_receive_a_cancellation_signal_from_the_console()
     {
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
+            """
+            [Command]
+            public class Command : ICommand
+            {
                 public async ValueTask ExecuteAsync(IConsole console)
                 {
                     try
@@ -34,15 +34,17 @@ public class Command : ICommand
                             console.RegisterCancellationHandler()
                         );
 
-            console.Output.WriteLine(""Completed successfully"");
+                        console.Output.WriteLine("Completed successfully");
                     }
                     catch (OperationCanceledException)
                     {
-            console.Output.WriteLine(""Cancelled"");
+                        console.Output.WriteLine("Cancelled");
                         throw;
                     }
                 }
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -63,5 +65,4 @@ public class Command : ICommand
         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.6.1" />
+    <PackageReference Include="FluentAssertions" Version="6.11.0" />
+    <PackageReference Include="GitHubActionsTestLogger" Version="2.0.2" PrivateAssets="all" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.5.0" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="7.0.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.5.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,23 +1,27 @@
 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)
     {
     }
 
-        [Fact]
+    [Fact(Timeout = 15000)]
     public async Task Real_console_maps_directly_to_system_console()
     {
         // Can't verify our own console output, so using an
@@ -27,7 +31,8 @@ namespace CliFx.Tests
         var command = "Hello world" | Cli.Wrap("dotnet")
             .WithArguments(a => a
                 .Add(Dummy.Program.Location)
-                    .Add("console-test"));
+                .Add("console-test")
+            );
 
         // Act
         var result = await command.ExecuteBufferedAsync();
@@ -43,25 +48,28 @@ namespace CliFx.Tests
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{   
+            """
+            [Command]
+            public class Command : ICommand
+            {
                 public ValueTask ExecuteAsync(IConsole console)
                 {
                     console.ResetColor();
                     console.ForegroundColor = ConsoleColor.DarkMagenta;
                     console.BackgroundColor = ConsoleColor.DarkMagenta;
+                    console.WindowWidth = 100;
+                    console.WindowHeight = 25;
                     console.CursorLeft = 42;
                     console.CursorTop = 24;
 
-        console.Output.WriteLine(""Hello "");
-        console.Error.WriteLine(""world!"");
+                    console.Output.WriteLine("Hello ");
+                    console.Error.WriteLine("world!");
 
                     return default;
                 }
-}
-");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -77,14 +85,16 @@ public class Command : ICommand
         // Assert
         exitCode.Should().Be(0);
 
-            Console.OpenStandardInput().Should().NotBe(FakeConsole.Input.BaseStream);
-            Console.OpenStandardOutput().Should().NotBe(FakeConsole.Output.BaseStream);
-            Console.OpenStandardError().Should().NotBe(FakeConsole.Error.BaseStream);
+        Console.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);
 
@@ -99,10 +109,10 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{   
+            """
+            [Command]
+            public class Command : ICommand
+            {
                 public ValueTask ExecuteAsync(IConsole console)
                 {
                     var input = console.Input.ReadToEnd();
@@ -111,8 +121,9 @@ public class Command : ICommand
 
                     return default;
                 }
-}
-");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -135,5 +146,69 @@ public class Command : ICommand
         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/ConversionSpecs.cs

@@ -6,10 +6,10 @@ using FluentAssertions;
 using Xunit;
 using Xunit.Abstractions;
 
-namespace CliFx.Tests
+namespace CliFx.Tests;
+
+public class ConversionSpecs : SpecsBase
 {
-    public class ConversionSpecs : SpecsBase
-    {
     public ConversionSpecs(ITestOutputHelper testOutput)
         : base(testOutput)
     {
@@ -21,10 +21,10 @@ namespace CliFx.Tests
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
+            """
+            [Command]
+            public class Command : ICommand
+            {
                 [CommandOption('f')]
                 public string Foo { get; set; }
 
@@ -33,8 +33,10 @@ public class Command : ICommand
                     console.Output.WriteLine(Foo);
                     return default;
                 }
-}
-");
+            }
+            """
+        );
+
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -59,10 +61,10 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
+            """
+            [Command]
+            public class Command : ICommand
+            {
                 [CommandOption('f')]
                 public object Foo { get; set; }
 
@@ -71,8 +73,10 @@ public class Command : ICommand
                     console.Output.WriteLine(Foo);
                     return default;
                 }
-}
-");
+            }
+            """
+        );
+
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -97,10 +101,10 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
+            """
+            [Command]
+            public class Command : ICommand
+            {
                 [CommandOption('f')]
                 public bool Foo { get; set; }
 
@@ -109,13 +113,15 @@ public class Command : ICommand
 
                 public ValueTask ExecuteAsync(IConsole console)
                 {
-        console.Output.WriteLine(""Foo = "" + Foo);
-        console.Output.WriteLine(""Bar = "" + Bar);
+                    console.Output.WriteLine("Foo = " + Foo);
+                    console.Output.WriteLine("Bar = " + Bar);
 
                     return default;
                 }
-}
-");
+            }
+            """
+        );
+
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -143,10 +149,10 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
+            """
+            [Command]
+            public class Command : ICommand
+            {
                 [CommandOption('f')]
                 public bool Foo { get; set; }
 
@@ -155,8 +161,10 @@ public class Command : ICommand
                     console.Output.WriteLine(Foo);
                     return default;
                 }
-}
-");
+            }
+            """
+        );
+
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -181,10 +189,10 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
+            """
+            [Command]
+            public class Command : ICommand
+            {
                 [CommandOption('f')]
                 public int Foo { get; set; }
 
@@ -193,8 +201,10 @@ public class Command : ICommand
                     console.Output.WriteLine(Foo);
                     return default;
                 }
-}
-");
+            }
+            """
+        );
+
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -219,10 +229,10 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
+            """
+            [Command]
+            public class Command : ICommand
+            {
                 [CommandOption('f')]
                 public double Foo { get; set; }
 
@@ -231,8 +241,10 @@ public class Command : ICommand
                     console.Output.WriteLine(Foo.ToString(CultureInfo.InvariantCulture));
                     return default;
                 }
-}
-");
+            }
+            """
+        );
+
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -257,20 +269,22 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
+            """
+            [Command]
+            public class Command : ICommand
+            {
                 [CommandOption('f')]
                 public DateTimeOffset Foo { get; set; }
 
                 public ValueTask ExecuteAsync(IConsole console)
                 {
-        console.Output.WriteLine(Foo.ToString(""u"", CultureInfo.InvariantCulture));
+                    console.Output.WriteLine(Foo.ToString("u", CultureInfo.InvariantCulture));
                     return default;
                 }
-}
-");
+            }
+            """
+        );
+
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -295,10 +309,10 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
+            """
+            [Command]
+            public class Command : ICommand
+            {
                 [CommandOption('f')]
                 public TimeSpan Foo { get; set; }
 
@@ -307,8 +321,10 @@ public class Command : ICommand
                     console.Output.WriteLine(Foo.ToString(null, CultureInfo.InvariantCulture));
                     return default;
                 }
-}
-");
+            }
+            """
+        );
+
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -333,12 +349,12 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-public enum CustomEnum { One = 1, Two = 2, Three = 3 }
+            """
+            public enum CustomEnum { One = 1, Two = 2, Three = 3 }
 
-[Command]
-public class Command : ICommand
-{
+            [Command]
+            public class Command : ICommand
+            {
                 [CommandOption('f')]
                 public CustomEnum Foo { get; set; }
 
@@ -347,8 +363,10 @@ public class Command : ICommand
                     console.Output.WriteLine((int) Foo);
                     return default;
                 }
-}
-");
+            }
+            """
+        );
+
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -373,10 +391,10 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
+            """
+            [Command]
+            public class Command : ICommand
+            {
                 [CommandOption('f')]
                 public int? Foo { get; set; }
 
@@ -385,13 +403,15 @@ public class Command : ICommand
 
                 public ValueTask ExecuteAsync(IConsole console)
                 {
-        console.Output.WriteLine(""Foo = "" + Foo);
-        console.Output.WriteLine(""Bar = "" + Bar);
+                    console.Output.WriteLine("Foo = " + Foo);
+                    console.Output.WriteLine("Bar = " + Bar);
 
                     return default;
                 }
-}
-");
+            }
+            """
+        );
+
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -419,12 +439,12 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-public enum CustomEnum { One = 1, Two = 2, Three = 3 }
+            """
+            public enum CustomEnum { One = 1, Two = 2, Three = 3 }
 
-[Command]
-public class Command : ICommand
-{
+            [Command]
+            public class Command : ICommand
+            {
                 [CommandOption('f')]
                 public CustomEnum? Foo { get; set; }
 
@@ -433,13 +453,15 @@ public class Command : ICommand
 
                 public ValueTask ExecuteAsync(IConsole console)
                 {
-        console.Output.WriteLine(""Foo = "" + (int?) Foo);
-        console.Output.WriteLine(""Bar = "" + (int?) Bar);
+                    console.Output.WriteLine("Foo = " + (int?) Foo);
+                    console.Output.WriteLine("Bar = " + (int?) Bar);
 
                     return default;
                 }
-}
-");
+            }
+            """
+        );
+
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -467,17 +489,17 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-public class CustomType
-{
+            """
+            public class CustomType
+            {
                 public string Value { get; }
 
                 public CustomType(string value) => Value = value;
-}
+            }
 
-[Command]
-public class Command : ICommand
-{
+            [Command]
+            public class Command : ICommand
+            {
                 [CommandOption('f')]
                 public CustomType Foo { get; set; }
 
@@ -486,8 +508,10 @@ public class Command : ICommand
                     console.Output.WriteLine(Foo.Value);
                     return default;
                 }
-}
-");
+            }
+            """
+        );
+
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -512,30 +536,30 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-public class CustomTypeA
-{
+            """
+            public class CustomTypeA
+            {
                 public string Value { get; }
 
                 private CustomTypeA(string value) => Value = value;
 
                 public static CustomTypeA Parse(string value) =>
                     new CustomTypeA(value);
-}
+            }
 
-public class CustomTypeB
-{
+            public class CustomTypeB
+            {
                 public string Value { get; }
 
                 private CustomTypeB(string value) => Value = value;
 
                 public static CustomTypeB Parse(string value, IFormatProvider formatProvider) =>
                     new CustomTypeB(value);
-}
+            }
 
-[Command]
-public class Command : ICommand
-{
+            [Command]
+            public class Command : ICommand
+            {
                 [CommandOption('f')]
                 public CustomTypeA Foo { get; set; }
 
@@ -544,13 +568,15 @@ public class Command : ICommand
 
                 public ValueTask ExecuteAsync(IConsole console)
                 {
-        console.Output.WriteLine(""Foo = "" + Foo.Value);
-        console.Output.WriteLine(""Bar = "" + Bar.Value);
+                    console.Output.WriteLine("Foo = " + Foo.Value);
+                    console.Output.WriteLine("Bar = " + Bar.Value);
 
                     return default;
                 }
-}
-");
+            }
+            """
+        );
+
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -578,16 +604,16 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-public class CustomConverter : BindingConverter<int>
-{
+            """
+            public class CustomConverter : BindingConverter<int>
+            {
                 public override int Convert(string rawValue) =>
                     rawValue.Length;
-}
+            }
 
-[Command]
-public class Command : ICommand
-{
+            [Command]
+            public class Command : ICommand
+            {
                 [CommandOption('f', Converter = typeof(CustomConverter))]
                 public int Foo { get; set; }
 
@@ -596,8 +622,10 @@ public class Command : ICommand
                     console.Output.WriteLine(Foo);
                     return default;
                 }
-}
-");
+            }
+            """
+        );
+
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -622,10 +650,10 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
+            """
+            [Command]
+            public class Command : ICommand
+            {
                 [CommandOption('f')]
                 public string[] Foo { get; set; }
 
@@ -636,8 +664,10 @@ public class Command : ICommand
 
                     return default;
                 }
-}
-");
+            }
+            """
+        );
+
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -666,10 +696,10 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
+            """
+            [Command]
+            public class Command : ICommand
+            {
                 [CommandOption('f')]
                 public IReadOnlyList<string> Foo { get; set; }
 
@@ -680,8 +710,10 @@ public class Command : ICommand
 
                     return default;
                 }
-}
-");
+            }
+            """
+        );
+
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -710,10 +742,10 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
+            """
+            [Command]
+            public class Command : ICommand
+            {
                 [CommandOption('f')]
                 public List<string> Foo { get; set; }
 
@@ -724,8 +756,10 @@ public class Command : ICommand
 
                     return default;
                 }
-}
-");
+            }
+            """
+        );
+
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -754,10 +788,10 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
+            """
+            [Command]
+            public class Command : ICommand
+            {
                 [CommandOption('f')]
                 public int[] Foo { get; set; }
 
@@ -768,8 +802,10 @@ public class Command : ICommand
 
                     return default;
                 }
-}
-");
+            }
+            """
+        );
+
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -798,16 +834,18 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
+            """
+            [Command]
+            public class Command : ICommand
+            {
                 [CommandOption('f')]
                 public int Foo { get; set; }
 
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+            }
+            """
+        );
+
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -832,18 +870,20 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-public class CustomType {}
+            """
+            public class CustomType {}
 
-[Command]
-public class Command : ICommand
-{
+            [Command]
+            public class Command : ICommand
+            {
                 [CommandOption('f')]
                 public CustomType Foo { get; set; }
 
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+            }
+            """
+        );
+
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -868,23 +908,25 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-public class CustomType : IEnumerable<object>
-{
+            """
+            public class CustomType : IEnumerable<object>
+            {
                 public IEnumerator<object> GetEnumerator() => Enumerable.Empty<object>().GetEnumerator();
 
                 IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
-}
+            }
 
-[Command]
-public class Command : ICommand
-{
+            [Command]
+            public class Command : ICommand
+            {
                 [CommandOption('f')]
                 public CustomType Foo { get; set; }
 
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+            }
+            """
+        );
+
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -909,26 +951,28 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-public class ValidatorA : BindingValidator<int>
-{
+            """
+            public class ValidatorA : BindingValidator<int>
+            {
                 public override BindingValidationError Validate(int value) => Ok();
-}
+            }
 
-public class ValidatorB : BindingValidator<int>
-{
-    public override BindingValidationError Validate(int value) => Error(""Hello world"");
-}
+            public class ValidatorB : BindingValidator<int>
+            {
+                public override BindingValidationError Validate(int value) => Error("Hello world");
+            }
 
-[Command]
-public class Command : ICommand
-{
+            [Command]
+            public class Command : ICommand
+            {
                 [CommandOption('f', Validators = new[] {typeof(ValidatorA), typeof(ValidatorB)})]
                 public int Foo { get; set; }
 
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+            }
+            """
+        );
+
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -946,5 +990,49 @@ public class Command : ICommand
         exitCode.Should().NotBe(0);
         stdErr.Should().Contain("Hello world");
     }
+
+    [Fact]
+    public async Task Parameter_or_option_value_conversion_fails_if_the_static_parse_method_throws()
+    {
+        // Arrange
+        var commandType = DynamicCommandBuilder.Compile(
+            // language=cs
+            """
+            public class CustomType
+            {
+                public string Value { get; }
+
+                private CustomType(string value) => Value = value;
+
+                public static CustomType Parse(string value) => throw new Exception("Hello world");
+            }
+
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                public CustomType Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """
+        );
+
+        var application = new CliApplicationBuilder()
+            .AddCommand(commandType)
+            .UseConsole(FakeConsole)
+            .Build();
+
+        // Act
+        var exitCode = await application.RunAsync(
+            new[] {"-f", "bar"},
+            new Dictionary<string, string>()
+        );
+
+        var stdErr = FakeConsole.ReadErrorString();
+
+        // Assert
+        exitCode.Should().NotBe(0);
+        stdErr.Should().Contain("Hello world");
     }
 }

CliFx.Tests/DirectivesSpecs.cs

@@ -10,62 +10,44 @@ 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)
     {
     }
 
-        [Fact]
+    [Fact(Timeout = 15000)]
     public async Task Debug_directive_can_be_specified_to_interrupt_execution_until_a_debugger_is_attached()
     {
         // Arrange
-            var stdOutBuffer = new StringBuilder();
+        using var cts = new CancellationTokenSource();
+
+        // We can't actually attach a debugger, but we can ensure that the process is waiting for one
+        void HandleStdOut(string line)
+        {
+            // Kill the process once it writes the output we expect
+            if (line.Contains("Attach debugger to", StringComparison.OrdinalIgnoreCase))
+                cts.Cancel();
+        }
 
         var command = Cli.Wrap("dotnet")
             .WithArguments(a => a
                 .Add(Dummy.Program.Location)
-                    .Add("[debug]")) | stdOutBuffer;
+                .Add("[debug]")
+            ) | HandleStdOut;
 
-            // Act
+        // Act & assert
         try
         {
-                // This has a timeout just in case the execution hangs forever
-                using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
-
-                var task = command.ExecuteAsync(cts.Token);
-
-                // We can't attach a debugger programmatically, so the application
-                // will hang indefinitely.
-                // To work around it, we will wait until the application writes
-                // something to the standard output and then kill it.
-                while (true)
+            await command.ExecuteAsync(cts.Token);
+        }
+        catch (OperationCanceledException ex) when (ex.CancellationToken == cts.Token)
         {
-                    if (stdOutBuffer.Length > 0)
-                    {
-                        cts.Cancel();
-                        break;
+            // This means that the process was killed after it wrote the expected output
         }
-
-                    await Task.Delay(100, cts.Token);
-                }
-
-                await task;
-            }
-            catch (OperationCanceledException)
-            {
-                // It's expected to fail
-            }
-
-            var stdOut = stdOutBuffer.ToString();
-
-            // Assert
-            stdOut.Should().Contain("Attach debugger to");
-
-            TestOutput.WriteLine(stdOut);
     }
 
     [Fact]
@@ -74,13 +56,14 @@ namespace CliFx.Tests
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command(""cmd"")]
-public class Command : ICommand
-{
+            """
+            [Command("cmd")]
+            public class Command : ICommand
+            {
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -108,5 +91,4 @@ public class Command : ICommand
             "ENV_KIL", "=", "\"world\""
         );
     }
-    }
 }

CliFx.Tests/EnvironmentSpecs.cs

@@ -10,10 +10,10 @@ using FluentAssertions;
 using Xunit;
 using Xunit.Abstractions;
 
-namespace CliFx.Tests
+namespace CliFx.Tests;
+
+public class EnvironmentSpecs : SpecsBase
 {
-    public class EnvironmentSpecs : SpecsBase
-    {
     public EnvironmentSpecs(ITestOutputHelper testOutput)
         : base(testOutput)
     {
@@ -25,11 +25,11 @@ namespace CliFx.Tests
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""foo"", IsRequired = true, EnvironmentVariable = ""ENV_FOO"")]
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo", IsRequired = true, EnvironmentVariable = "ENV_FOO")]
                 public string Foo { get; set; }
 
                 public ValueTask ExecuteAsync(IConsole console)
@@ -37,8 +37,9 @@ public class Command : ICommand
                     console.Output.WriteLine(Foo);
                     return default;
                 }
-}
-");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -67,11 +68,11 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""foo"", EnvironmentVariable = ""ENV_FOO"")]
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo", EnvironmentVariable = "ENV_FOO")]
                 public string Foo { get; set; }
 
                 public ValueTask ExecuteAsync(IConsole console)
@@ -79,8 +80,9 @@ public class Command : ICommand
                     console.Output.WriteLine(Foo);
                     return default;
                 }
-}
-");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -109,11 +111,11 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""foo"", EnvironmentVariable = ""ENV_FOO"")]
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo", EnvironmentVariable = "ENV_FOO")]
                 public IReadOnlyList<string> Foo { get; set; }
 
                 public ValueTask ExecuteAsync(IConsole console)
@@ -123,8 +125,9 @@ public class Command : ICommand
 
                     return default;
                 }
-}
-");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -156,11 +159,11 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""foo"", EnvironmentVariable = ""ENV_FOO"")]
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo", EnvironmentVariable = "ENV_FOO")]
                 public string Foo { get; set; }
 
                 public ValueTask ExecuteAsync(IConsole console)
@@ -168,8 +171,9 @@ public class Command : ICommand
                     console.Output.WriteLine(Foo);
                     return default;
                 }
-}
-");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -198,11 +202,11 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""foo"", EnvironmentVariable = ""ENV_FOO"")]
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo", EnvironmentVariable = "ENV_FOO")]
                 public string Foo { get; set; }
 
                 public ValueTask ExecuteAsync(IConsole console)
@@ -210,8 +214,9 @@ public class Command : ICommand
                     console.Output.WriteLine(Foo);
                     return default;
                 }
-}
-");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -236,7 +241,7 @@ public class Command : ICommand
         stdOut.Trim().Should().Be("bar");
     }
 
-        [Fact]
+    [Fact(Timeout = 15000)]
     public async Task Environment_variables_are_extracted_automatically()
     {
         // Ensures that the environment variables are properly obtained from
@@ -246,9 +251,11 @@ public class Command : ICommand
         var command = Cli.Wrap("dotnet")
             .WithArguments(a => a
                 .Add(Dummy.Program.Location)
-                    .Add("env-test"))
+                .Add("env-test")
+            )
             .WithEnvironmentVariables(e => e
-                    .Set("ENV_TARGET", "Mars"));
+                .Set("ENV_TARGET", "Mars")
+            );
 
         // Act
         var result = await command.ExecuteBufferedAsync();
@@ -256,5 +263,4 @@ public class Command : ICommand
         // Assert
         result.StandardOutput.Trim().Should().Be("Hello Mars!");
     }
-    }
 }

CliFx.Tests/ErrorReportingSpecs.cs

@@ -7,10 +7,10 @@ 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)
     {
@@ -22,14 +22,15 @@ namespace CliFx.Tests
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
+            """
+            [Command]
+            public class Command : ICommand
+            {
                 public ValueTask ExecuteAsync(IConsole console) =>
-        throw new Exception(""Something went wrong"");
-}
-");
+                    throw new Exception("Something went wrong");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -60,14 +61,15 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
+            """
+            [Command]
+            public class Command : ICommand
+            {
                 public ValueTask ExecuteAsync(IConsole console) =>
-        throw new Exception(""Something went wrong"", new Exception(""Another exception""));
-}
-");
+                    throw new Exception("Something went wrong", new Exception("Another exception"));
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -99,14 +101,15 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
+            """
+            [Command]
+            public class Command : ICommand
+            {
                 public ValueTask ExecuteAsync(IConsole console) =>
-        throw new CommandException(""Something went wrong"", 69);
-}
-");
+                    throw new CommandException("Something went wrong", 69);
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -134,14 +137,15 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
+            """
+            [Command]
+            public class Command : ICommand
+            {
                 public ValueTask ExecuteAsync(IConsole console) =>
-        throw new CommandException("""", 69);
-}
-");
+                    throw new CommandException("", 69);
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -172,14 +176,15 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
+            """
+            [Command]
+            public class Command : ICommand
+            {
                 public ValueTask ExecuteAsync(IConsole console) =>
-        throw new CommandException(""Something went wrong"", 69, true);
-}
-");
+                    throw new CommandException("Something went wrong", 69, true);
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -201,5 +206,4 @@ public class Command : ICommand
         stdOut.Should().Contain("This will be in help text");
         stdErr.Trim().Should().Be("Something went wrong");
     }
-    }
 }

CliFx.Tests/HelpTextSpecs.cs

@@ -7,10 +7,10 @@ using FluentAssertions;
 using Xunit;
 using Xunit.Abstractions;
 
-namespace CliFx.Tests
+namespace CliFx.Tests;
+
+public class HelpTextSpecs : SpecsBase
 {
-    public class HelpTextSpecs : SpecsBase
-    {
     public HelpTextSpecs(ITestOutputHelper testOutput)
         : base(testOutput)
     {
@@ -44,13 +44,14 @@ namespace CliFx.Tests
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class DefaultCommand : ICommand
-{
+            """
+            [Command]
+            public class DefaultCommand : ICommand
+            {
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -77,19 +78,20 @@ public class DefaultCommand : ICommand
         // Arrange
         var commandTypes = DynamicCommandBuilder.CompileMany(
             // language=cs
-                @"
-[Command(""cmd"")]
-public class NamedCommand : ICommand
-{
+            """
+            [Command("cmd")]
+            public class NamedCommand : ICommand
+            {
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}
+            }
 
-[Command(""cmd child"")]
-public class NamedChildCommand : ICommand
-{
+            [Command("cmd child")]
+            public class NamedChildCommand : ICommand
+            {
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommands(commandTypes)
@@ -116,25 +118,26 @@ public class NamedChildCommand : ICommand
         // Arrange
         var commandTypes = DynamicCommandBuilder.CompileMany(
             // language=cs
-                @"
-[Command]
-public class DefaultCommand : ICommand
-{
+            """
+            [Command]
+            public class DefaultCommand : ICommand
+            {
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}
+            }
 
-[Command(""cmd"", Description = ""Description of a named command."")]
-public class NamedCommand : ICommand
-{
+            [Command("cmd", Description = "Description of a named command.")]
+            public class NamedCommand : ICommand
+            {
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}
+            }
 
-[Command(""cmd child"")]
-public class NamedChildCommand : ICommand
-{
+            [Command("cmd child")]
+            public class NamedChildCommand : ICommand
+            {
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommands(commandTypes)
@@ -160,25 +163,26 @@ public class NamedChildCommand : ICommand
         // Arrange
         var commandTypes = DynamicCommandBuilder.CompileMany(
             // language=cs
-                @"
-[Command]
-public class DefaultCommand : ICommand
-{
+            """
+            [Command]
+            public class DefaultCommand : ICommand
+            {
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}
+            }
 
-[Command(""cmd"")]
-public class NamedCommand : ICommand
-{
+            [Command("cmd")]
+            public class NamedCommand : ICommand
+            {
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}
+            }
 
-[Command(""cmd child"", Description = ""Description of a named child command."")]
-public class NamedChildCommand : ICommand
-{
+            [Command("cmd child", Description = "Description of a named child command.")]
+            public class NamedChildCommand : ICommand
+            {
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommands(commandTypes)
@@ -257,13 +261,15 @@ public class NamedChildCommand : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command(Description = ""Description of the default command."")]
-public class DefaultCommand : ICommand
-{
+            """
+                
+                [Command(Description = "Description of the default command.")]
+                public class DefaultCommand : ICommand
+                {
                     public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+                }
+
+                """);
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -292,19 +298,21 @@ public class DefaultCommand : ICommand
         // Arrange
         var commandTypes = DynamicCommandBuilder.CompileMany(
             // language=cs
-                @"
-[Command]
-public class DefaultCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
+            """
                 
-[Command(""cmd"")]
-public class NamedCommand : ICommand
-{
+                [Command]
+                public class DefaultCommand : ICommand
+                {
                     public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+                }
+                
+                [Command("cmd")]
+                public class NamedCommand : ICommand
+                {
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
+
+                """);
 
         var application = new CliApplicationBuilder()
             .AddCommands(commandTypes)
@@ -333,10 +341,11 @@ public class NamedCommand : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
+            """
+                
+                [Command]
+                public class Command : ICommand
+                {
                     [CommandParameter(0)]
                     public string Foo { get; set; }
                 
@@ -347,8 +356,9 @@ public class Command : ICommand
                     public IReadOnlyList<string> Baz { get; set; }
                 
                     public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+                }
+
+                """);
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -371,28 +381,83 @@ public class Command : ICommand
         );
     }
 
+    // https://github.com/Tyrrrz/CliFx/issues/117
+    [Fact]
+    public async Task Help_text_shows_usage_format_which_lists_all_parameters_in_specified_order()
+    {
+        // Arrange
+        var commandType = DynamicCommandBuilder.Compile(
+            // language=cs
+            """
+                
+                // Base members appear last in reflection order
+                public abstract class CommandBase : ICommand
+                {
+                    [CommandParameter(0)]
+                    public string Foo { get; set; }
+                
+                    public abstract ValueTask ExecuteAsync(IConsole console);
+                }
+                
+                [Command]
+                public class Command : CommandBase
+                {
+                    [CommandParameter(2)]
+                    public IReadOnlyList<string> Baz { get; set; }
+                
+                    [CommandParameter(1)]
+                    public string Bar { get; set; }
+                
+                    public override ValueTask ExecuteAsync(IConsole console) => default;
+                }
+
+                """);
+
+        var application = new CliApplicationBuilder()
+            .AddCommand(commandType)
+            .UseConsole(FakeConsole)
+            .Build();
+
+        // Act
+        var exitCode = await application.RunAsync(
+            new[] { "--help" },
+            new Dictionary<string, string>()
+        );
+
+        var stdOut = FakeConsole.ReadOutputString();
+
+        // Assert
+        exitCode.Should().Be(0);
+        stdOut.Should().ContainAllInOrder(
+            "USAGE",
+            "<foo>", "<bar>", "<baz...>"
+        );
+    }
+
     [Fact]
     public async Task Help_text_shows_usage_format_which_lists_all_required_options()
     {
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""foo"", IsRequired = true)]
+            """
+                
+                [Command]
+                public class Command : ICommand
+                {
+                    [CommandOption("foo", IsRequired = true)]
                     public string Foo { get; set; }
                 
-    [CommandOption(""bar"")]
+                    [CommandOption("bar")]
                     public string Bar { get; set; }
                 
-    [CommandOption(""baz"", IsRequired = true)]
+                    [CommandOption("baz", IsRequired = true)]
                     public IReadOnlyList<string> Baz { get; set; }
                 
                     public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+                }
+
+                """);
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -421,19 +486,21 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
-    [CommandParameter(0, Name = ""foo"", Description = ""Description of foo."")]
+            """
+                
+                [Command]
+                public class Command : ICommand
+                {
+                    [CommandParameter(0, Name = "foo", Description = "Description of foo.")]
                     public string Foo { get; set; }
                 
-    [CommandOption(""bar"", Description = ""Description of bar."")]
+                    [CommandOption("bar", Description = "Description of bar.")]
                     public string Bar { get; set; }
                 
                     public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+                }
+
+                """);
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -464,13 +531,15 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
+            """
+                
+                [Command]
+                public class Command : ICommand
+                {
                     public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+                }
+
+                """);
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -500,13 +569,15 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command(""cmd"")]
-public class Command : ICommand
-{
+            """
+                
+                [Command("cmd")]
+                public class Command : ICommand
+                {
                     public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+                }
+
+                """);
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -538,21 +609,117 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-public enum CustomEnum { One, Two, Three }
+            """
                 
-[Command]
-public class Command : ICommand
-{
+                public enum CustomEnum { One, Two, Three }
+                
+                [Command]
+                public class Command : ICommand
+                {
                     [CommandParameter(0)]
                     public CustomEnum Foo { get; set; }
                 
-    [CommandOption(""bar"")]
+                    [CommandOption("bar")]
                     public CustomEnum 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[] {"--help"},
+            new Dictionary<string, string>()
+        );
+
+        var stdOut = FakeConsole.ReadOutputString();
+
+        // Assert
+        exitCode.Should().Be(0);
+        stdOut.Should().ContainAllInOrder(
+            "PARAMETERS",
+            "foo", "Choices:", "One", "Two", "Three",
+            "OPTIONS",
+            "--bar", "Choices:", "One", "Two", "Three"
+        );
+    }
+
+    [Fact]
+    public async Task Help_text_shows_all_valid_values_for_non_scalar_enum_parameters_and_options()
+    {
+        // Arrange
+        var commandType = DynamicCommandBuilder.Compile(
+            // language=cs
+            """
+                
+                public enum CustomEnum { One, Two, Three }
+                
+                [Command]
+                public class Command : ICommand
+                {
+                    [CommandParameter(0)]
+                    public IReadOnlyList<CustomEnum> Foo { get; set; }
+                
+                    [CommandOption("bar")]
+                    public IReadOnlyList<CustomEnum> 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[] {"--help"},
+            new Dictionary<string, string>()
+        );
+
+        var stdOut = FakeConsole.ReadOutputString();
+
+        // Assert
+        exitCode.Should().Be(0);
+        stdOut.Should().ContainAllInOrder(
+            "PARAMETERS",
+            "foo", "Choices:", "One", "Two", "Three",
+            "OPTIONS",
+            "--bar", "Choices:", "One", "Two", "Three"
+        );
+    }
+
+    [Fact]
+    public async Task Help_text_shows_all_valid_values_for_nullable_enum_parameters_and_options()
+    {
+        // Arrange
+        var commandType = DynamicCommandBuilder.Compile(
+            // language=cs
+            """
+                
+                public enum CustomEnum { One, Two, Three }
+                
+                [Command]
+                public class Command : ICommand
+                {
+                    [CommandParameter(0)]
+                    public CustomEnum? Foo { get; set; }
+                
+                    [CommandOption("bar")]
+                    public IReadOnlyList<CustomEnum?> Bar { get; set; }
+                
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
+
+                """);
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -583,21 +750,23 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-public enum CustomEnum { One, Two, Three }
+            """
                 
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""foo"", EnvironmentVariable = ""ENV_FOO"")]
+                public enum CustomEnum { One, Two, Three }
+                
+                [Command]
+                public class Command : ICommand
+                {
+                    [CommandOption("foo", EnvironmentVariable = "ENV_FOO")]
                     public CustomEnum Foo { get; set; }
                 
-    [CommandOption(""bar"", EnvironmentVariable = ""ENV_BAR"")]
+                    [CommandOption("bar", EnvironmentVariable = "ENV_BAR")]
                     public CustomEnum Bar { get; set; }
                 
                     public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+                }
+
+                """);
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -627,39 +796,41 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-public enum CustomEnum { One, Two, Three }
+            """
                 
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""foo"")]
+                public enum CustomEnum { One, Two, Three }
+                
+                [Command]
+                public class Command : ICommand
+                {
+                    [CommandOption("foo")]
                     public object Foo { get; set; } = 42;
                 
-    [CommandOption(""bar"")]
-    public string Bar { get; set; } = ""hello"";
+                    [CommandOption("bar")]
+                    public string Bar { get; set; } = "hello";
                 
-    [CommandOption(""baz"")]
-    public IReadOnlyList<string> Baz { get; set; } = new[] {""one"", ""two"", ""three""};
+                    [CommandOption("baz")]
+                    public IReadOnlyList<string> Baz { get; set; } = new[] {"one", "two", "three"};
                 
-    [CommandOption(""qwe"")]
+                    [CommandOption("qwe")]
                     public bool Qwe { get; set; } = true;
                 
-    [CommandOption(""qop"")]
+                    [CommandOption("qop")]
                     public int? Qop { get; set; } = 1337;
                 
-    [CommandOption(""zor"")]
+                    [CommandOption("zor")]
                     public TimeSpan Zor { get; set; } = TimeSpan.FromMinutes(123);
                 
-    [CommandOption(""lol"")]
+                    [CommandOption("lol")]
                     public CustomEnum Lol { get; set; } = CustomEnum.Two;
                 
-    [CommandOption(""hmm"", IsRequired = true)]
-    public string Hmm { get; set; } = ""not printed"";
+                    [CommandOption("hmm", IsRequired = true)]
+                    public string Hmm { get; set; } = "not printed";
                 
                     public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+                }
+
+                """);
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -695,25 +866,27 @@ public class Command : ICommand
         // Arrange
         var commandTypes = DynamicCommandBuilder.CompileMany(
             // language=cs
-                @"
-[Command(""cmd1"", Description = ""Description of one command."")]
-public class FirstCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
+            """
                 
-[Command(""cmd2"", Description = ""Description of another command."")]
-public class SecondCommand : ICommand
-{
+                [Command("cmd1", Description = "Description of one command.")]
+                public class FirstCommand : ICommand
+                {
                     public ValueTask ExecuteAsync(IConsole console) => default;
-}
+                }
                 
-[Command(""cmd2 child"", Description = ""Description of another command's child command."")]
-public class SecondCommandChildCommand : ICommand
-{
+                [Command("cmd2", Description = "Description of another command.")]
+                public class SecondCommand : ICommand
+                {
                     public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+                }
+                
+                [Command("cmd2 child", Description = "Description of another command's child command.")]
+                public class SecondCommandChildCommand : ICommand
+                {
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
+
+                """);
 
         var application = new CliApplicationBuilder()
             .AddCommands(commandTypes)
@@ -749,37 +922,39 @@ public class SecondCommandChildCommand : ICommand
         // Arrange
         var commandTypes = DynamicCommandBuilder.CompileMany(
             // language=cs
-                @"
-[Command(""cmd1"")]
-public class FirstCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
+            """
                 
-[Command(""cmd1 child1"")]
-public class FirstCommandFirstChildCommand : ICommand
-{
+                [Command("cmd1")]
+                public class FirstCommand : ICommand
+                {
                     public ValueTask ExecuteAsync(IConsole console) => default;
-}
+                }
                 
-[Command(""cmd2"")]
-public class SecondCommand : ICommand
-{
+                [Command("cmd1 child1")]
+                public class FirstCommandFirstChildCommand : ICommand
+                {
                     public ValueTask ExecuteAsync(IConsole console) => default;
-}
+                }
                 
-[Command(""cmd2 child11"")]
-public class SecondCommandFirstChildCommand : ICommand
-{
+                [Command("cmd2")]
+                public class SecondCommand : ICommand
+                {
                     public ValueTask ExecuteAsync(IConsole console) => default;
-}
+                }
                 
-[Command(""cmd2 child2"")]
-public class SecondCommandSecondChildCommand : ICommand
-{
+                [Command("cmd2 child11")]
+                public class SecondCommandFirstChildCommand : ICommand
+                {
                     public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+                }
+                
+                [Command("cmd2 child2")]
+                public class SecondCommandSecondChildCommand : ICommand
+                {
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
+
+                """);
 
         var application = new CliApplicationBuilder()
             .AddCommands(commandTypes)
@@ -809,25 +984,27 @@ public class SecondCommandSecondChildCommand : ICommand
         // Arrange
         var commandTypes = DynamicCommandBuilder.CompileMany(
             // language=cs
-                @"
-[Command(""cmd1"")]
-public class FirstCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
+            """
                 
-[Command(""cmd2 child1"")]
-public class SecondCommandFirstChildCommand : ICommand
-{
+                [Command("cmd1")]
+                public class FirstCommand : ICommand
+                {
                     public ValueTask ExecuteAsync(IConsole console) => default;
-}
+                }
                 
-[Command(""cmd2 child2"")]
-public class SecondCommandSecondChildCommand : ICommand
-{
+                [Command("cmd2 child1")]
+                public class SecondCommandFirstChildCommand : ICommand
+                {
                     public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+                }
+                
+                [Command("cmd2 child2")]
+                public class SecondCommandSecondChildCommand : ICommand
+                {
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
+
+                """);
 
         var application = new CliApplicationBuilder()
             .AddCommands(commandTypes)
@@ -874,5 +1051,4 @@ public class SecondCommandSecondChildCommand : ICommand
         exitCode.Should().Be(0);
         stdOut.Trim().Should().Be("v6.9");
     }
-    }
 }

CliFx.Tests/OptionBindingSpecs.cs

@@ -7,10 +7,10 @@ using FluentAssertions;
 using Xunit;
 using Xunit.Abstractions;
 
-namespace CliFx.Tests
+namespace CliFx.Tests;
+
+public class OptionBindingSpecs : SpecsBase
 {
-    public class OptionBindingSpecs : SpecsBase
-    {
     public OptionBindingSpecs(ITestOutputHelper testOutput)
         : base(testOutput)
     {
@@ -22,11 +22,11 @@ namespace CliFx.Tests
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""foo"")]
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo")]
                 public bool Foo { get; set; }
 
                 public ValueTask ExecuteAsync(IConsole console)
@@ -34,7 +34,9 @@ public class Command : ICommand
                     console.Output.WriteLine(Foo);
                     return default;
                 }
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -60,10 +62,10 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
+            """
+            [Command]
+            public class Command : ICommand
+            {
                 [CommandOption('f')]
                 public bool Foo { get; set; }
 
@@ -72,7 +74,9 @@ public class Command : ICommand
                     console.Output.WriteLine(Foo);
                     return default;
                 }
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -98,24 +102,26 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""foo"")]
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo")]
                 public string Foo { get; set; }
 
-    [CommandOption(""bar"")]
+                [CommandOption("bar")]
                 public string Bar { get; set; }
 
                 public ValueTask ExecuteAsync(IConsole console)
                 {
-        console.Output.WriteLine(""Foo = "" + Foo);
-        console.Output.WriteLine(""Bar = "" + Bar);
+                    console.Output.WriteLine("Foo = " + Foo);
+                    console.Output.WriteLine("Bar = " + Bar);
 
                     return default;
                 }
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -144,10 +150,10 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
+            """
+            [Command]
+            public class Command : ICommand
+            {
                 [CommandOption('f')]
                 public string Foo { get; set; }
 
@@ -156,12 +162,14 @@ public class Command : ICommand
 
                 public ValueTask ExecuteAsync(IConsole console)
                 {
-        console.Output.WriteLine(""Foo = "" + Foo);
-        console.Output.WriteLine(""Bar = "" + Bar);
+                    console.Output.WriteLine("Foo = " + Foo);
+                    console.Output.WriteLine("Bar = " + Bar);
 
                     return default;
                 }
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -190,10 +198,10 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
+            """
+            [Command]
+            public class Command : ICommand
+            {
                 [CommandOption('f')]
                 public string Foo { get; set; }
 
@@ -202,12 +210,14 @@ public class Command : ICommand
 
                 public ValueTask ExecuteAsync(IConsole console)
                 {
-        console.Output.WriteLine(""Foo = "" + Foo);
-        console.Output.WriteLine(""Bar = "" + Bar);
+                    console.Output.WriteLine("Foo = " + Foo);
+                    console.Output.WriteLine("Bar = " + Bar);
 
                     return default;
                 }
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -236,11 +246,11 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""Foo"")]
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("Foo")]
                 public IReadOnlyList<string> Foo { get; set; }
 
                 public ValueTask ExecuteAsync(IConsole console)
@@ -250,7 +260,9 @@ public class Command : ICommand
 
                     return default;
                 }
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -280,10 +292,10 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
+            """
+            [Command]
+            public class Command : ICommand
+            {
                 [CommandOption('f')]
                 public IReadOnlyList<string> Foo { get; set; }
 
@@ -294,7 +306,9 @@ public class Command : ICommand
 
                     return default;
                 }
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -324,11 +338,11 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""foo"")]
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo")]
                 public IReadOnlyList<string> Foo { get; set; }
 
                 public ValueTask ExecuteAsync(IConsole console)
@@ -338,7 +352,9 @@ public class Command : ICommand
 
                     return default;
                 }
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -368,10 +384,10 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
+            """
+            [Command]
+            public class Command : ICommand
+            {
                 [CommandOption('f')]
                 public IReadOnlyList<string> Foo { get; set; }
 
@@ -382,7 +398,9 @@ public class Command : ICommand
 
                     return default;
                 }
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -412,11 +430,11 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""foo"", 'f')]
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo", 'f')]
                 public IReadOnlyList<string> Foo { get; set; }
 
                 public ValueTask ExecuteAsync(IConsole console)
@@ -426,7 +444,9 @@ public class Command : ICommand
 
                     return default;
                 }
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -456,24 +476,26 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""foo"")]
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo")]
                 public string Foo { get; set; }
 
-    [CommandOption(""bar"")]
-    public string Bar { get; set; } = ""hello"";
+                [CommandOption("bar")]
+                public string Bar { get; set; } = "hello";
 
                 public ValueTask ExecuteAsync(IConsole console)
                 {
-        console.Output.WriteLine(""Foo = "" + Foo);
-        console.Output.WriteLine(""Bar = "" + Bar);
+                    console.Output.WriteLine("Foo = " + Foo);
+                    console.Output.WriteLine("Bar = " + Bar);
 
                     return default;
                 }
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -496,17 +518,95 @@ public class Command : ICommand
         );
     }
 
+    [Fact]
+    public async Task Option_binding_supports_multiple_inheritance_through_default_interface_members()
+    {
+        // Arrange
+        var commandType = DynamicCommandBuilder.Compile(
+            // language=cs
+            """
+            public static class SharedContext
+            {
+                public static int Foo { get; set; }
+
+                public static bool Bar { get; set; }
+            }
+
+            public interface IHasFoo : ICommand
+            {
+                [CommandOption("foo")]
+                public int Foo
+                {
+                    get => SharedContext.Foo;
+                    set => SharedContext.Foo = value;
+                }
+            }
+
+            public interface IHasBar : ICommand
+            {
+                [CommandOption("bar")]
+                public bool Bar
+                {
+                    get => SharedContext.Bar;
+                    set => SharedContext.Bar = value;
+                }
+            }
+
+            public interface IHasBaz : ICommand
+            {
+                public string Baz { get; set; }
+            }
+
+            [Command]
+            public class Command : IHasFoo, IHasBar, IHasBaz
+            {
+                [CommandOption("baz")]
+                public string Baz { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("Foo = " + SharedContext.Foo);
+                    console.Output.WriteLine("Bar = " + SharedContext.Bar);
+                    console.Output.WriteLine("Baz = " + Baz);
+
+                    return default;
+                }
+            }
+            """
+        );
+
+        var application = new CliApplicationBuilder()
+            .AddCommand(commandType)
+            .UseConsole(FakeConsole)
+            .Build();
+
+        // Act
+        var exitCode = await application.RunAsync(
+            new[] { "--foo", "42", "--bar", "--baz", "xyz" }
+        );
+
+        var stdOut = FakeConsole.ReadOutputString();
+
+        // Assert
+        exitCode.Should().Be(0);
+        stdOut.Should().ConsistOfLines(
+            "Foo = 42",
+            "Bar = True",
+            "Baz = xyz"
+        );
+    }
+
     [Fact]
     public async Task Option_binding_does_not_consider_a_negative_number_as_an_option_name_or_short_name()
     {
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""foo"")]
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo")]
                 public string Foo { get; set; }
 
                 public ValueTask ExecuteAsync(IConsole console)
@@ -515,7 +615,9 @@ public class Command : ICommand
 
                     return default;
                 }
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -541,15 +643,17 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""foo"", IsRequired = true)]
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo", IsRequired = true)]
                 public string Foo { get; set; }
 
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -575,15 +679,17 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""foo"", IsRequired = true)]
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo", IsRequired = true)]
                 public string Foo { get; set; }
 
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -609,15 +715,17 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""foo"", IsRequired = true)]
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo", IsRequired = true)]
                 public IReadOnlyList<string> Foo { get; set; }
 
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -643,15 +751,17 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""foo"")]
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo")]
                 public string Foo { get; set; }
 
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -677,15 +787,17 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""foo"")]
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo")]
                 public string Foo { get; set; }
 
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -704,5 +816,40 @@ public class Command : ICommand
         exitCode.Should().NotBe(0);
         stdErr.Should().Contain("expects a single argument, but provided with multiple");
     }
+
+    [Fact]
+    public async Task Option_binding_fails_if_a_required_property_option_has_not_been_provided()
+    {
+        // Arrange
+        var commandType = DynamicCommandBuilder.Compile(
+            // language=cs
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo")]
+                public required string Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """
+        );
+
+        var application = new CliApplicationBuilder()
+            .AddCommand(commandType)
+            .UseConsole(FakeConsole)
+            .Build();
+
+        // Act
+        var exitCode = await application.RunAsync(
+            Array.Empty<string>(),
+            new Dictionary<string, string>()
+        );
+
+        var stdErr = FakeConsole.ReadErrorString();
+
+        // Assert
+        exitCode.Should().NotBe(0);
+        stdErr.Should().Contain("Missing required option(s)");
     }
 }

CliFx.Tests/ParameterBindingSpecs.cs

@@ -6,10 +6,10 @@ 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)
     {
@@ -21,10 +21,10 @@ namespace CliFx.Tests
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
+            """
+            [Command]
+            public class Command : ICommand
+            {
                 [CommandParameter(0)]
                 public string Foo { get; set; }
 
@@ -33,12 +33,14 @@ public class Command : ICommand
 
                 public ValueTask ExecuteAsync(IConsole console)
                 {
-        console.Output.WriteLine(""Foo = "" + Foo);
-        console.Output.WriteLine(""Bar = "" + Bar);
+                    console.Output.WriteLine("Foo = " + Foo);
+                    console.Output.WriteLine("Bar = " + Bar);
 
                     return default;
                 }
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -67,10 +69,10 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
+            """
+            [Command]
+            public class Command : ICommand
+            {
                 [CommandParameter(0)]
                 public string Foo { get; set; }
 
@@ -80,20 +82,22 @@ public class Command : ICommand
                 [CommandParameter(2)]
                 public IReadOnlyList<string> Baz { get; set; }
 
-    [CommandOption(""boo"")]
+                [CommandOption("boo")]
                 public string Boo { get; set; }
 
                 public ValueTask ExecuteAsync(IConsole console)
                 {
-        console.Output.WriteLine(""Foo = "" + Foo);
-        console.Output.WriteLine(""Bar = "" + Bar);
+                    console.Output.WriteLine("Foo = " + Foo);
+                    console.Output.WriteLine("Bar = " + Bar);
 
                     foreach (var i in Baz)
-            console.Output.WriteLine(""Baz = "" + i);
+                        console.Output.WriteLine("Baz = " + i);
 
                     return default;
                 }
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -120,15 +124,63 @@ public class Command : ICommand
     }
 
     [Fact]
-        public async Task Parameter_binding_fails_if_one_of_the_parameters_has_not_been_provided()
+    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
-{
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandParameter(0)]
+                public string Foo { get; set; }
+
+                [CommandParameter(1, IsRequired = false)]
+                public string Bar { get; set; } = "xyz";
+
+                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[] {"abc"},
+            new Dictionary<string, string>()
+        );
+
+        var stdOut = FakeConsole.ReadOutputString();
+
+        // Assert
+        exitCode.Should().Be(0);
+        stdOut.Should().ConsistOfLines(
+            "Foo = abc",
+            "Bar = xyz"
+        );
+    }
+
+    [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; }
 
@@ -136,7 +188,9 @@ public class Command : ICommand
                 public string Bar { get; set; }
 
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -153,7 +207,7 @@ public class Command : ICommand
 
         // Assert
         exitCode.Should().NotBe(0);
-            stdErr.Should().Contain("Missing parameter(s)");
+        stdErr.Should().Contain("Missing required parameter(s)");
     }
 
     [Fact]
@@ -162,10 +216,10 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
+            """
+            [Command]
+            public class Command : ICommand
+            {
                 [CommandParameter(0)]
                 public string Foo { get; set; }
 
@@ -173,7 +227,9 @@ public class Command : ICommand
                 public IReadOnlyList<string> Bar { get; set; }
 
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -190,7 +246,7 @@ public class Command : ICommand
 
         // Assert
         exitCode.Should().NotBe(0);
-            stdErr.Should().Contain("Missing parameter(s)");
+        stdErr.Should().Contain("Missing required parameter(s)");
     }
 
     [Fact]
@@ -199,10 +255,10 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-                @"
-[Command]
-public class Command : ICommand
-{
+            """
+            [Command]
+            public class Command : ICommand
+            {
                 [CommandParameter(0)]
                 public string Foo { get; set; }
 
@@ -210,7 +266,9 @@ public class Command : ICommand
                 public string Bar { get; set; }
 
                 public ValueTask ExecuteAsync(IConsole console) => default;
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -229,5 +287,4 @@ public class Command : ICommand
         exitCode.Should().NotBe(0);
         stdErr.Should().Contain("Unexpected parameter(s)");
     }
-    }
 }

CliFx.Tests/RoutingSpecs.cs

@@ -6,10 +6,10 @@ using FluentAssertions;
 using Xunit;
 using Xunit.Abstractions;
 
-namespace CliFx.Tests
+namespace CliFx.Tests;
+
+public class RoutingSpecs : SpecsBase
 {
-    public class RoutingSpecs : SpecsBase
-    {
     public RoutingSpecs(ITestOutputHelper testOutput)
         : base(testOutput)
     {
@@ -21,37 +21,38 @@ namespace CliFx.Tests
         // Arrange
         var commandTypes = DynamicCommandBuilder.CompileMany(
             // language=cs
-                @"
-[Command]
-public class DefaultCommand : ICommand
-{
+            """
+            [Command]
+            public class DefaultCommand : ICommand
+            {
                 public ValueTask ExecuteAsync(IConsole console)
                 {
-        console.Output.WriteLine(""default"");
+                    console.Output.WriteLine("default");
                     return default;
                 }
-}
+            }
 
-[Command(""cmd"")]
-public class NamedCommand : ICommand
-{
+            [Command("cmd")]
+            public class NamedCommand : ICommand
+            {
                 public ValueTask ExecuteAsync(IConsole console)
                 {
-        console.Output.WriteLine(""cmd"");
+                    console.Output.WriteLine("cmd");
                     return default;
                 }
-}
+            }
 
-[Command(""cmd child"")]
-public class NamedChildCommand : ICommand
-{
+            [Command("cmd child")]
+            public class NamedChildCommand : ICommand
+            {
                 public ValueTask ExecuteAsync(IConsole console)
                 {
-        console.Output.WriteLine(""cmd child"");
+                    console.Output.WriteLine("cmd child");
                     return default;
                 }
-}
-");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommands(commandTypes)
@@ -77,37 +78,38 @@ public class NamedChildCommand : ICommand
         // Arrange
         var commandTypes = DynamicCommandBuilder.CompileMany(
             // language=cs
-                @"
-[Command]
-public class DefaultCommand : ICommand
-{
+            """
+            [Command]
+            public class DefaultCommand : ICommand
+            {
                 public ValueTask ExecuteAsync(IConsole console)
                 {
-        console.Output.WriteLine(""default"");
+                    console.Output.WriteLine("default");
                     return default;
                 }
-}
+            }
 
-[Command(""cmd"")]
-public class NamedCommand : ICommand
-{
+            [Command("cmd")]
+            public class NamedCommand : ICommand
+            {
                 public ValueTask ExecuteAsync(IConsole console)
                 {
-        console.Output.WriteLine(""cmd"");
+                    console.Output.WriteLine("cmd");
                     return default;
                 }
-}
+            }
 
-[Command(""cmd child"")]
-public class NamedChildCommand : ICommand
-{
+            [Command("cmd child")]
+            public class NamedChildCommand : ICommand
+            {
                 public ValueTask ExecuteAsync(IConsole console)
                 {
-        console.Output.WriteLine(""cmd child"");
+                    console.Output.WriteLine("cmd child");
                     return default;
                 }
-}
-");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommands(commandTypes)
@@ -133,37 +135,38 @@ public class NamedChildCommand : ICommand
         // Arrange
         var commandTypes = DynamicCommandBuilder.CompileMany(
             // language=cs
-                @"
-[Command]
-public class DefaultCommand : ICommand
-{
+            """
+            [Command]
+            public class DefaultCommand : ICommand
+            {
                 public ValueTask ExecuteAsync(IConsole console)
                 {
-        console.Output.WriteLine(""default"");
+                    console.Output.WriteLine("default");
                     return default;
                 }
-}
+            }
 
-[Command(""cmd"")]
-public class NamedCommand : ICommand
-{
+            [Command("cmd")]
+            public class NamedCommand : ICommand
+            {
                 public ValueTask ExecuteAsync(IConsole console)
                 {
-        console.Output.WriteLine(""cmd"");
+                    console.Output.WriteLine("cmd");
                     return default;
                 }
-}
+            }
 
-[Command(""cmd child"")]
-public class NamedChildCommand : ICommand
-{
+            [Command("cmd child")]
+            public class NamedChildCommand : ICommand
+            {
                 public ValueTask ExecuteAsync(IConsole console)
                 {
-        console.Output.WriteLine(""cmd child"");
+                    console.Output.WriteLine("cmd child");
                     return default;
                 }
-}
-");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommands(commandTypes)
@@ -182,5 +185,4 @@ public class NamedChildCommand : ICommand
         exitCode.Should().Be(0);
         stdOut.Trim().Should().Be("cmd child");
     }
-    }
 }