Update version

Closes #135

.github/ISSUE_TEMPLATE/config.yml

@@ -1,5 +1,8 @@
 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.

.github/ISSUE_TEMPLATE/feature-request.yml

@@ -1,22 +0,0 @@
-name: ✨ Feature request
-description: Request a new feature.
-labels: [enhancement]
-
-body:
-- type: markdown
-  attributes:
-    value: |
-      🧐 **Guidelines:**
-
-      - Search through [existing issues](https://github.com/Tyrrrz/CliFx/issues?q=is%3Aissue) first to ensure that this feature has not been requested before.
-      - Write a descriptive title for your issue. Avoid generic or vague titles such as "Some suggestions" or "Ideas for improvement".
-      - Keep your issue focused on one single problem. If you have multiple feature requests, please create separate issues for each of them.
-      - Provide as much context as possible in the details section. Include screenshots, screen recordings, links, references, or anything else you may consider relevant.
-      - If you want to ask a question instead of requesting a feature, please use [discussions](https://github.com/Tyrrrz/CliFx/discussions/new) instead.
-
-- type: textarea
-  attributes:
-    label: Details
-    description: Clear and thorough explanation of the feature you have in mind.
-  validations:
-    required: true

.github/workflows/main.yml

@@ -4,7 +4,9 @@ on: [push, pull_request]
 
 jobs:
   main:
-    uses: Tyrrrz/.github/.github/workflows/NuGet.yml@master
+    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 }}

Changelog.md

@@ -1,43 +1,103 @@
-### v2.1 (04-Jan-2022)
+# Changelog
+
+## v2.3.4 (18-May-2023)
+
+- Added an overload of `CliApplicationBuilder.UseTypeActivator(...)` that accepts a `Func<IReadOnlyList<Type>, IServiceProvider>` delegate. The first parameter in the delegate is the list of all command types registered in the application. You can use this overload to more easily add the commands to a DI container. See the readme for an [updated example](https://github.com/Tyrrrz/CliFx/tree/2.3.4#type-activation).
+
+## 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)
+## 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)
+## 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)
+## 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)
+## 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)
+## 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)
+## 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)
+## 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.
@@ -54,7 +114,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.
@@ -68,34 +128,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))
@@ -103,7 +163,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))
@@ -114,7 +174,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>net6.0</TargetFramework>
+    <TargetFramework>net7.0</TargetFramework>
-    <IsPackable>false</IsPackable>
-    <IsTestProject>true</IsTestProject>
-    <CollectCoverage>true</CollectCoverage>
-    <CoverletOutputFormat>opencover</CoverletOutputFormat>
   </PropertyGroup>
 
   <ItemGroup>
@@ -13,14 +9,14 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Basic.Reference.Assemblies" Version="1.2.4" />
+    <PackageReference Include="Basic.Reference.Assemblies.Net70" Version="1.4.2" />
-    <PackageReference Include="GitHubActionsTestLogger" Version="1.2.0" />
+    <PackageReference Include="GitHubActionsTestLogger" Version="2.2.0" PrivateAssets="all" />
-    <PackageReference Include="FluentAssertions" Version="6.2.0" />
+    <PackageReference Include="FluentAssertions" Version="6.11.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.6.0" />
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.0.1" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.6.0" />
-    <PackageReference Include="xunit" Version="2.4.1" />
+    <PackageReference Include="xunit" Version="2.4.2" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3" PrivateAssets="all" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5" PrivateAssets="all" />
-    <PackageReference Include="coverlet.msbuild" Version="3.1.0" PrivateAssets="all" />
+    <PackageReference Include="coverlet.collector" Version="3.2.0" PrivateAssets="all" />
   </ItemGroup>
 
   <ItemGroup>

CliFx.Analyzers.Tests/CommandMustBeAnnotatedAnalyzerSpecs.cs

@@ -13,11 +13,13 @@ public class CommandMustBeAnnotatedAnalyzerSpecs
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-public class MyCommand : ICommand
+            """
-{
+            public class MyCommand : ICommand
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            {
-}";
+                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 = @"
+        const string code =
-[Command]
+            """
-public abstract class MyCommand : ICommand
+            [Command]
-{
+            public abstract class MyCommand : ICommand
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            {
-}";
+                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 = @"
+        const string code =
-public abstract class MyCommand : ICommand
+            """
-{
+            public abstract class MyCommand : ICommand
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            {
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -59,11 +65,13 @@ public abstract class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-public class Foo
+            """
-{
+            public class Foo
-    public int Bar { get; set; } = 5;
+            {
-}";
+                public int Bar { get; init; } = 5;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);

CliFx.Analyzers.Tests/CommandMustImplementInterfaceAnalyzerSpecs.cs

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

CliFx.Analyzers.Tests/OptionMustBeInsideCommandAnalyzerSpecs.cs

@@ -13,12 +13,14 @@ public class OptionMustBeInsideCommandAnalyzerSpecs
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-public class MyClass
+            """
-{
+            public class MyClass
-    [CommandOption(""foo"")]
+            {
-    public string Foo { get; set; }
+                [CommandOption("foo")]
-}";
+                public string? Foo { get; init; }
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -29,15 +31,17 @@ public class MyClass
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandOption(""foo"")]
+            {
-    public string Foo { get; set; }
+                [CommandOption("foo")]
+                public string? Foo { get; init; }
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                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 = @"
+        const string code =
-public abstract class MyCommand
+            """
-{
+            public abstract class MyCommand
-    [CommandOption(""foo"")]
+            {
-    public string Foo { get; set; }
+                [CommandOption("foo")]
-}";
+                public string? Foo { get; init; }
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -64,14 +70,16 @@ public abstract class MyCommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    public string Foo { get; set; }
+            {
+                public string? Foo { get; init; }
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                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; init; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_required_option_is_bound_to_a_required_property()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption('f')]
+                public required string Foo { get; init; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_non_required_option_is_bound_to_a_non_required_property()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption('f', IsRequired = false)]
+                public string? Foo { get; init; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_required_option_is_bound_to_a_non_required_property()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption('f')]
+                public required string Foo { get; init; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_on_a_property_that_is_not_an_option()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public required string Foo { get; init; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+}

CliFx.Analyzers.Tests/OptionMustHaveNameOrShortNameAnalyzerSpecs.cs

@@ -13,15 +13,17 @@ public class OptionMustHaveNameOrShortNameAnalyzerSpecs
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandOption(null)]
+            {
-    public string Foo { get; set; }
+                [CommandOption(null)]
-    
+                public string? Foo { get; init; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                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 = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandOption(""foo"")]
+            {
-    public string Foo { get; set; }
+                [CommandOption("foo")]
-    
+                public string? Foo { get; init; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                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 = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandOption('f')]
+            {
-    public string Foo { get; set; }
+                [CommandOption('f')]
-    
+                public string? Foo { get; init; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -70,14 +76,16 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    public string Foo { get; set; }
+            {
-
+                public string? Foo { get; init; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);

CliFx.Analyzers.Tests/OptionMustHaveUniqueNameAnalyzerSpecs.cs

@@ -13,18 +13,20 @@ public class OptionMustHaveUniqueNameAnalyzerSpecs
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandOption(""foo"")]
+            {
-    public string Foo { get; set; }
+                [CommandOption("foo")]
-    
+                public string? Foo { get; init; }
-    [CommandOption(""foo"")]
+            
-    public string Bar { get; set; }
+                [CommandOption("foo")]
-
+                public string? Bar { get; init; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                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 = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandOption(""foo"")]
+            {
-    public string Foo { get; set; }
+                [CommandOption("foo")]
-    
+                public string? Foo { get; init; }
-    [CommandOption(""bar"")]
+            
-    public string Bar { get; set; }
+                [CommandOption("bar")]
-
+                public string? Bar { get; init; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                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 = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandOption('f')]
+            {
-    public string Foo { get; set; }
+                [CommandOption('f')]
-    
+                public string? Foo { get; init; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -76,14 +82,16 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    public string Foo { get; set; }
+            {
-
+                public string? Foo { get; init; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);

CliFx.Analyzers.Tests/OptionMustHaveUniqueShortNameAnalyzerSpecs.cs

@@ -13,18 +13,20 @@ public class OptionMustHaveUniqueShortNameAnalyzerSpecs
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandOption('f')]
+            {
-    public string Foo { get; set; }
+                [CommandOption('f')]
-    
+                public string? Foo { get; init; }
-    [CommandOption('f')]
+            
-    public string Bar { get; set; }
+                [CommandOption('f')]
-
+                public string? Bar { get; init; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                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 = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandOption('f')]
+            {
-    public string Foo { get; set; }
+                [CommandOption('f')]
-    
+                public string? Foo { get; init; }
-    [CommandOption('b')]
+            
-    public string Bar { get; set; }
+                [CommandOption('b')]
-
+                public string? Bar { get; init; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -57,18 +61,20 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandOption('f')]
+            {
-    public string Foo { get; set; }
+                [CommandOption('f')]
-    
+                public string? Foo { get; init; }
-    [CommandOption('F')]
+            
-    public string Bar { get; set; }
+                [CommandOption('F')]
-
+                public string? Bar { get; init; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                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 = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandOption(""foo"")]
+            {
-    public string Foo { get; set; }
+                [CommandOption("foo")]
-    
+                public string? Foo { get; init; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -98,14 +106,16 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    public string Foo { get; set; }
+            {
-
+                public string? Foo { get; init; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);

CliFx.Analyzers.Tests/OptionMustHaveValidConverterAnalyzerSpecs.cs

@@ -9,48 +9,130 @@ 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 = @"
+        const string code =
-public class MyConverter
+            """
-{
+            public class MyConverter
-    public string Convert(string rawValue) => rawValue;
+            {
-}
+                public string Convert(string? rawValue) => rawValue;
+            }
 
-[Command]
+            [Command]
-public class MyCommand : ICommand
+            public class MyCommand : ICommand
-{
+            {
-    [CommandOption(""foo"", Converter = typeof(MyConverter))]
+                [CommandOption("foo", Converter = typeof(MyConverter))]
-    public string Foo { get; set; }
+                public string? Foo { get; init; }
-    
+
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                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 = @"
+        const string code =
-public class MyConverter : BindingConverter<string>
+            """
-{
+            public class MyConverter : BindingConverter<int>
-    public override string Convert(string rawValue) => rawValue;
+            {
-}
+                public override int Convert(string? rawValue) => 42;
+            }
 
-[Command]
+            [Command]
-public class MyCommand : ICommand
+            public class MyCommand : ICommand
-{
+            {
-    [CommandOption(""foo"", Converter = typeof(MyConverter))]
+                [CommandOption("foo", Converter = typeof(MyConverter))]
-    public string Foo { get; set; }
+                public string? Foo { get; init; }
-    
+
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                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; init; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_nullable_option_has_a_converter_that_derives_from_a_compatible_BindingConverter()
+    {
+        // Arrange
+        // 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; init; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_non_scalar_option_has_a_converter_that_derives_from_a_compatible_BindingConverter()
+    {
+        // Arrange
+        // 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; init; }
+
+                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 = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandOption(""foo"")]
+            {
-    public string Foo { get; set; }
+                [CommandOption("foo")]
-    
+                public string? Foo { get; init; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -80,14 +164,16 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    public string Foo { get; set; }
+            {
+                public string? Foo { get; init; }
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);

CliFx.Analyzers.Tests/OptionMustHaveValidNameAnalyzerSpecs.cs

@@ -13,15 +13,17 @@ public class OptionMustHaveValidNameAnalyzerSpecs
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandOption(""f"")]
+            {
-    public string Foo { get; set; }
+                [CommandOption("f")]
-    
+                public string? Foo { get; init; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                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 = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandOption(""1foo"")]
+            {
-    public string Foo { get; set; }
+                [CommandOption("1foo")]
-    
+                public string? Foo { get; init; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                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 = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandOption(""foo"")]
+            {
-    public string Foo { get; set; }
+                [CommandOption("foo")]
-    
+                public string? Foo { get; init; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                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 = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandOption('f')]
+            {
-    public string Foo { get; set; }
+                [CommandOption('f')]
-    
+                public string? Foo { get; init; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -89,14 +97,16 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    public string Foo { get; set; }
+            {
-
+                public string? Foo { get; init; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);

CliFx.Analyzers.Tests/OptionMustHaveValidShortNameAnalyzerSpecs.cs

@@ -13,15 +13,17 @@ public class OptionMustHaveValidShortNameAnalyzerSpecs
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandOption('1')]
+            {
-    public string Foo { get; set; }
+                [CommandOption('1')]
-    
+                public string? Foo { get; init; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                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 = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandOption('f')]
+            {
-    public string Foo { get; set; }
+                [CommandOption('f')]
-    
+                public string? Foo { get; init; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                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 = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandOption(""foo"")]
+            {
-    public string Foo { get; set; }
+                [CommandOption("foo")]
-    
+                public string? Foo { get; init; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -70,14 +76,16 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    public string Foo { get; set; }
+            {
-
+                public string? Foo { get; init; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);

CliFx.Analyzers.Tests/OptionMustHaveValidValidatorsAnalyzerSpecs.cs

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

CliFx.Analyzers.Tests/ParameterMustBeInsideCommandAnalyzerSpecs.cs

@@ -13,12 +13,14 @@ public class ParameterMustBeInsideCommandAnalyzerSpecs
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-public class MyClass
+            """
-{
+            public class MyClass
-    [CommandParameter(0)]
+            {
-    public string Foo { get; set; }
+                [CommandParameter(0)]
-}";
+                public required string Foo { get; init; }
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -29,15 +31,17 @@ public class MyClass
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandParameter(0)]
+            {
-    public string Foo { get; set; }
+                [CommandParameter(0)]
+                public required string Foo { get; init; }
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                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 = @"
+        const string code =
-public abstract class MyCommand
+            """
-{
+            public abstract class MyCommand
-    [CommandParameter(0)]
+            {
-    public string Foo { get; set; }
+                [CommandParameter(0)]
-}";
+                public required string Foo { get; init; }
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -64,14 +70,16 @@ public abstract class MyCommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    public string Foo { get; set; }
+            {
+                public string? Foo { get; init; }
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                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; init; }
+
+                [CommandParameter(1)]
+                public required string Bar { get; init; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_non_required_parameter_is_the_last_in_order()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0)]
+                public required string Foo { get; init; }
+
+                [CommandParameter(1, IsRequired = false)]
+                public string? Bar { get; init; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_no_non_required_parameters_are_defined()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0)]
+                public required string Foo { get; init; }
+
+                [CommandParameter(1)]
+                public required string Bar { get; init; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_on_a_property_that_is_not_a_parameter()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public string? Foo { get; init; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+}

CliFx.Analyzers.Tests/ParameterMustBeLastIfNonScalarAnalyzerSpecs.cs

@@ -9,44 +9,48 @@ 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 = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandParameter(0)]
+            {
-    public string[] Foo { get; set; }
+                [CommandParameter(0)]
-    
+                public required string[] Foo { get; init; }
-    [CommandParameter(1)]
-    public string Bar { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                [CommandParameter(1)]
-}";
+                public required string Bar { get; init; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
     }
 
     [Fact]
-    public void Analyzer_does_not_report_an_error_if_a_non_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 = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandParameter(0)]
+            {
-    public string Foo { get; set; }
+                [CommandParameter(0)]
-    
+                public required string Foo { get; init; }
-    [CommandParameter(1)]
-    public string[] Bar { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                [CommandParameter(1)]
-}";
+                public required string[] Bar { get; init; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -57,18 +61,20 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandParameter(0)]
+            {
-    public string Foo { get; set; }
+                [CommandParameter(0)]
-    
+                public required string Foo { get; init; }
-    [CommandParameter(1)]
-    public string Bar { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                [CommandParameter(1)]
-}";
+                public required string Bar { get; init; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -79,14 +85,16 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    public string Foo { get; set; }
+            {
+                public string? Foo { get; init; }
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                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; init; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_required_parameter_is_bound_to_a_required_property()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0)]
+                public required string Foo { get; init; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_non_required_parameter_is_bound_to_a_non_required_property()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0, IsRequired = false)]
+                public string? Foo { get; init; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_required_parameter_is_bound_to_a_non_required_property()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandParameter(0)]
+                public required string Foo { get; init; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_on_a_property_that_is_not_a_parameter()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public required string Foo { get; init; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+}

CliFx.Analyzers.Tests/ParameterMustBeSingleIfNonRequiredAnalyzerSpecs.cs

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

CliFx.Analyzers.Tests/ParameterMustBeSingleIfNonScalarAnalyzerSpecs.cs

@@ -13,18 +13,20 @@ public class ParameterMustBeSingleIfNonScalarAnalyzerSpecs
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandParameter(0)]
+            {
-    public string[] Foo { get; set; }
+                [CommandParameter(0)]
-    
+                public required string[] Foo { get; init; }
-    [CommandParameter(1)]
-    public string[] Bar { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                [CommandParameter(1)]
-}";
+                public required string[] Bar { get; init; }
+
+                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 = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandParameter(0)]
+            {
-    public string Foo { get; set; }
+                [CommandParameter(0)]
-    
+                public required string Foo { get; init; }
-    [CommandParameter(1)]
-    public string[] Bar { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                [CommandParameter(1)]
-}";
+                public required string[] Bar { get; init; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -57,18 +61,20 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandParameter(0)]
+            {
-    public string Foo { get; set; }
+                [CommandParameter(0)]
-    
+                public required string Foo { get; init; }
-    [CommandParameter(1)]
-    public string Bar { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                [CommandParameter(1)]
-}";
+                public required string Bar { get; init; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -79,14 +85,16 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    public string Foo { get; set; }
+            {
+                public string? Foo { get; init; }
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);

CliFx.Analyzers.Tests/ParameterMustHaveUniqueNameAnalyzerSpecs.cs

@@ -13,18 +13,20 @@ public class ParameterMustHaveUniqueNameAnalyzerSpecs
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandParameter(0, Name = ""foo"")]
+            {
-    public string Foo { get; set; }
+                [CommandParameter(0, Name = "foo")]
-    
+                public required string Foo { get; init; }
-    [CommandParameter(1, Name = ""foo"")]
-    public string Bar { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                [CommandParameter(1, Name = "foo")]
-}";
+                public required string Bar { get; init; }
+
+                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 = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandParameter(0, Name = ""foo"")]
+            {
-    public string Foo { get; set; }
+                [CommandParameter(0, Name = "foo")]
-    
+                public required string Foo { get; init; }
-    [CommandParameter(1, Name = ""bar"")]
-    public string Bar { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                [CommandParameter(1, Name = "bar")]
-}";
+                public required string Bar { get; init; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -57,14 +61,16 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    public string Foo { get; set; }
+            {
+                public string? Foo { get; init; }
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);

CliFx.Analyzers.Tests/ParameterMustHaveUniqueOrderAnalyzerSpecs.cs

@@ -13,18 +13,20 @@ public class ParameterMustHaveUniqueOrderAnalyzerSpecs
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandParameter(0)]
+            {
-    public string Foo { get; set; }
+                [CommandParameter(0)]
-    
+                public required string Foo { get; init; }
-    [CommandParameter(0)]
-    public string Bar { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                [CommandParameter(0)]
-}";
+                public required string Bar { get; init; }
+
+                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 = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandParameter(0)]
+            {
-    public string Foo { get; set; }
+                [CommandParameter(0)]
-    
+                public required string Foo { get; init; }
-    [CommandParameter(1)]
-    public string Bar { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                [CommandParameter(1)]
-}";
+                public required string Bar { get; init; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -57,14 +61,16 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    public string Foo { get; set; }
+            {
+                public string? Foo { get; init; }
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);

CliFx.Analyzers.Tests/ParameterMustHaveValidConverterAnalyzerSpecs.cs

@@ -9,48 +9,131 @@ 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 = @"
+        const string code =
-public class MyConverter
+            """
-{
+            public class MyConverter
-    public string Convert(string rawValue) => rawValue;
+            {
-}
+                public string Convert(string? rawValue) => rawValue;
+            }
 
-[Command]
+            [Command]
-public class MyCommand : ICommand
+            public class MyCommand : ICommand
-{
+            {
-    [CommandParameter(0, Converter = typeof(MyConverter))]
+                [CommandParameter(0, Converter = typeof(MyConverter))]
-    public string Foo { get; set; }
+                public required string Foo { get; init; }
-    
+
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                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 = @"
+        const string code =
-public class MyConverter : BindingConverter<string>
+            """
-{
+            public class MyConverter : BindingConverter<int>
-    public override string Convert(string rawValue) => rawValue;
+            {
-}
+                public override int Convert(string? rawValue) => 42;
+            }
 
-[Command]
+            [Command]
-public class MyCommand : ICommand
+            public class MyCommand : ICommand
-{
+            {
-    [CommandParameter(0, Converter = typeof(MyConverter))]
+                [CommandParameter(0, Converter = typeof(MyConverter))]
-    public string Foo { get; set; }
+                public required string Foo { get; init; }
-    
+
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                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 required string Foo { get; init; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_nullable_parameter_has_a_converter_that_derives_from_a_compatible_BindingConverter()
+    {
+        // Arrange
+        // 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; init; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_non_scalar_parameter_has_a_converter_that_derives_from_a_compatible_BindingConverter()
+    {
+        // Arrange
+        // 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 required IReadOnlyList<string> Foo { get; init; }
+
+                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 = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandParameter(0)]
+            {
-    public string Foo { get; set; }
+                [CommandParameter(0)]
-    
+                public required string Foo { get; init; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -80,14 +165,16 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    public string Foo { get; set; }
+            {
+                public string? Foo { get; init; }
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);

CliFx.Analyzers.Tests/ParameterMustHaveValidValidatorsAnalyzerSpecs.cs

@@ -9,48 +9,78 @@ 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 = @"
+        const string code =
-public class MyValidator
+            """
-{
+            public class MyValidator
-    public void Validate(string value) {}
+            {
-}
+                public void Validate(string value) {}
+            }
 
-[Command]
+            [Command]
-public class MyCommand : ICommand
+            public class MyCommand : ICommand
-{
+            {
-    [CommandParameter(0, Validators = new[] {typeof(MyValidator)})]
+                [CommandParameter(0, Validators = new[] {typeof(MyValidator)})]
-    public string Foo { get; set; }
+                public required string Foo { get; init; }
-    
+
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                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 = @"
+        const string code =
-public class MyValidator : BindingValidator<string>
+            """
-{
+            public class MyValidator : BindingValidator<int>
-    public override BindingValidationError Validate(string value) => Ok();
+            {
-}
+                public override BindingValidationError Validate(int value) => Ok();
+            }
 
-[Command]
+            [Command]
-public class MyCommand : ICommand
+            public class MyCommand : ICommand
-{
+            {
-    [CommandParameter(0, Validators = new[] {typeof(MyValidator)})]
+                [CommandParameter(0, Validators = new[] {typeof(MyValidator)})]
-    public string Foo { get; set; }
+                public required string Foo { get; init; }
-    
+
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                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 required string Foo { get; init; }
+
+                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 = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandParameter(0)]
+            {
-    public string Foo { get; set; }
+                [CommandParameter(0)]
-    
+                public required string Foo { get; init; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -80,14 +112,16 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    public string Foo { get; set; }
+            {
+                public string? Foo { get; init; }
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);

CliFx.Analyzers.Tests/SystemConsoleShouldBeAvoidedAnalyzerSpecs.cs

@@ -13,16 +13,18 @@ public class SystemConsoleShouldBeAvoidedAnalyzerSpecs
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    public ValueTask ExecuteAsync(IConsole console)
+            {
-    {
+                public ValueTask ExecuteAsync(IConsole console)
-        Console.WriteLine(""Hello world"");
+                {
-        return default;
+                    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 = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    public ValueTask ExecuteAsync(IConsole console)
+            {
-    {
+                public ValueTask ExecuteAsync(IConsole console)
-        Console.ForegroundColor = ConsoleColor.Black;
+                {
-        return default;
+                    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 = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    public ValueTask ExecuteAsync(IConsole console)
+            {
-    {
+                public ValueTask ExecuteAsync(IConsole console)
-        Console.Error.WriteLine(""Hello world"");
+                {
-        return default;
+                    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 = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    public ValueTask ExecuteAsync(IConsole console)
+            {
-    {
+                public ValueTask ExecuteAsync(IConsole console)
-        console.Output.WriteLine(""Hello world"");
+                {
-        return default;
+                    console.Output.WriteLine("Hello world");
-    }
+                    return default;
-}";
+                }
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -92,14 +101,16 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    public void SomeOtherMethod() => Console.WriteLine(""Test"");
+            {
-
+                public void SomeOtherMethod() => Console.WriteLine("Test");
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -110,15 +121,17 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    public ValueTask ExecuteAsync(IConsole console)
+            {
-    {
+                public ValueTask ExecuteAsync(IConsole console)
-        return default;
+                {
-    }
+                    return default;
-}";
+                }
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);

CliFx.Analyzers.Tests/Utils/AnalyzerAssertions.cs

@@ -57,8 +57,8 @@ internal class AnalyzerAssertions : ReferenceTypeAssertions<DiagnosticAnalyzer,
         // Compile the code to IL
         var compilation = CSharpCompilation.Create(
             "CliFxTests_DynamicAssembly_" + Guid.NewGuid(),
-            new[] {ast},
+            new[] { ast },
-            ReferenceAssemblies.Net50
+            Net70.References.All
                 .Append(MetadataReference.CreateFromFile(typeof(ICommand).Assembly.Location)),
             // DLL to avoid having to define the Main() method
             new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)
@@ -72,9 +72,10 @@ internal class AnalyzerAssertions : ReferenceTypeAssertions<DiagnosticAnalyzer,
         if (compilationErrors.Any())
         {
             throw new InvalidOperationException(
-                "Failed to compile code." +
+                $"""
-                Environment.NewLine +
+                Failed to compile code.
-                string.Join(Environment.NewLine, compilationErrors.Select(e => e.ToString()))
+                {string.Join(Environment.NewLine, compilationErrors.Select(e => e.ToString()))}
+                """
             );
         }
 
@@ -101,11 +102,11 @@ internal class AnalyzerAssertions : ReferenceTypeAssertions<DiagnosticAnalyzer,
         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();
 
@@ -125,10 +126,17 @@ internal class AnalyzerAssertions : ReferenceTypeAssertions<DiagnosticAnalyzer,
 
             buffer.AppendLine("Produced diagnostics:");
 
-            foreach (var producedDiagnostic in producedDiagnostics)
+            if (producedDiagnostics.Any())
             {
-                buffer.Append("  - ");
+                foreach (var producedDiagnostic in producedDiagnostics)
-                buffer.Append(producedDiagnostic);
+                {
+                    buffer.Append("  - ");
+                    buffer.Append(producedDiagnostic);
+                }
+            }
+            else
+            {
+                buffer.AppendLine("  < none >");
             }
 
             return new FailReason(buffer.ToString());
@@ -138,10 +146,9 @@ internal class AnalyzerAssertions : ReferenceTypeAssertions<DiagnosticAnalyzer,
     public void NotProduceDiagnostics(string sourceCode)
     {
         var producedDiagnostics = GetProducedDiagnostics(sourceCode);
+        var isSuccessfulAssertion = !producedDiagnostics.Any();
 
-        var result = !producedDiagnostics.Any();
+        Execute.Assertion.ForCondition(isSuccessfulAssertion).FailWith(() =>
-
-        Execute.Assertion.ForCondition(result).FailWith(() =>
         {
             var buffer = new StringBuilder();
 

CliFx.Analyzers/AnalyzerBase.cs

@@ -28,8 +28,8 @@ public abstract class AnalyzerBase : DiagnosticAnalyzer
         SupportedDiagnostics = ImmutableArray.Create(SupportedDiagnostic);
     }
 
-    protected Diagnostic CreateDiagnostic(Location location) =>
+    protected Diagnostic CreateDiagnostic(Location location, params object?[]? messageArgs) =>
-        Diagnostic.Create(SupportedDiagnostic, location);
+        Diagnostic.Create(SupportedDiagnostic, location, messageArgs);
 
     public override void Initialize(AnalysisContext context)
     {

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

@@ -30,18 +30,20 @@ public class CommandMustBeAnnotatedAnalyzer : AnalyzerBase
 
         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())
+            );
         }
     }
 

CliFx.Analyzers/CommandMustImplementInterfaceAnalyzer.cs

@@ -25,17 +25,19 @@ public class CommandMustImplementInterfaceAnalyzer : AnalyzerBase
         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())
+            );
         }
     }
 

CliFx.Analyzers/ObjectModel/CommandOptionSymbol.cs

@@ -1,28 +1,36 @@
 using System.Collections.Generic;
-using Microsoft.CodeAnalysis;
 using System.Linq;
 using CliFx.Analyzers.Utils.Extensions;
+using Microsoft.CodeAnalysis;
 
 namespace CliFx.Analyzers.ObjectModel;
 
-internal partial class CommandOptionSymbol
+internal partial class CommandOptionSymbol : ICommandMemberSymbol
 {
+    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;
     }
@@ -30,25 +38,34 @@ internal partial class CommandOptionSymbol
 
 internal partial class CommandOptionSymbol
 {
-    private static AttributeData? TryGetOptionAttribute(IPropertySymbol property) =>
+    private static AttributeData? TryGetOptionAttribute(IPropertySymbol property) => property
-        property
+        .GetAttributes()
-            .GetAttributes()
+        .FirstOrDefault(a => a.AttributeClass?.DisplayNameMatches(SymbolNames.CliFxCommandOptionAttribute) == true);
-            .FirstOrDefault(a => a.AttributeClass.DisplayNameMatches(SymbolNames.CliFxCommandOptionAttribute));
 
-    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,17 +81,7 @@ internal partial class CommandOptionSymbol
             .Cast<ITypeSymbol>()
             .ToArray();
 
-        return new CommandOptionSymbol(name, shortName, converter, validators);
+        return new CommandOptionSymbol(property, name, shortName, isRequired, converter, validators);
-    }
-
-    public static CommandOptionSymbol? TryResolve(IPropertySymbol property)
-    {
-        var attribute = TryGetOptionAttribute(property);
-
-        if (attribute is null)
-            return null;
-
-        return FromAttribute(attribute);
     }
 
     public static bool IsOptionProperty(IPropertySymbol property) =>

CliFx.Analyzers/ObjectModel/CommandParameterSymbol.cs

@@ -5,24 +5,32 @@ using Microsoft.CodeAnalysis;
 
 namespace CliFx.Analyzers.ObjectModel;
 
-internal partial class CommandParameterSymbol
+internal partial class CommandParameterSymbol : ICommandMemberSymbol
 {
+    public IPropertySymbol Property { get; }
+
     public int Order { get; }
 
     public string? Name { get; }
 
+    public bool? IsRequired { get; }
+
     public ITypeSymbol? ConverterType { get; }
 
     public IReadOnlyList<ITypeSymbol> ValidatorTypes { get; }
 
     public CommandParameterSymbol(
+        IPropertySymbol property,
         int order,
         string? name,
+        bool? isRequired,
         ITypeSymbol? converterType,
         IReadOnlyList<ITypeSymbol> validatorTypes)
     {
+        Property = property;
         Order = order;
         Name = name;
+        IsRequired = isRequired;
         ConverterType = converterType;
         ValidatorTypes = validatorTypes;
     }
@@ -30,14 +38,17 @@ internal partial class CommandParameterSymbol
 
 internal partial class CommandParameterSymbol
 {
-    private static AttributeData? TryGetParameterAttribute(IPropertySymbol property) =>
+    private static AttributeData? TryGetParameterAttribute(IPropertySymbol property) => property
-        property
+        .GetAttributes()
-            .GetAttributes()
+        .FirstOrDefault(a => a.AttributeClass?.DisplayNameMatches(SymbolNames.CliFxCommandParameterAttribute) == true);
-            .FirstOrDefault(a => a.AttributeClass.DisplayNameMatches(SymbolNames.CliFxCommandParameterAttribute));
 
-    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 @@ internal partial class CommandParameterSymbol
             .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,17 +80,7 @@ internal partial class CommandParameterSymbol
             .Cast<ITypeSymbol>()
             .ToArray();
 
-        return new CommandParameterSymbol(order, name, converter, validators);
+        return new CommandParameterSymbol(property, order, name, isRequired, converter, validators);
-    }
-
-    public static CommandParameterSymbol? TryResolve(IPropertySymbol property)
-    {
-        var attribute = TryGetParameterAttribute(property);
-
-        if (attribute is null)
-            return null;
-
-        return FromAttribute(attribute);
     }
 
     public static bool IsParameterProperty(IPropertySymbol property) =>

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

@@ -7,8 +7,6 @@ internal static class SymbolNames
     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

@@ -34,11 +34,13 @@ public class OptionMustBeInsideCommandAnalyzer : AnalyzerBase
         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())
+            );
         }
     }
 

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

@@ -27,7 +27,9 @@ public class OptionMustHaveNameOrShortNameAnalyzer : AnalyzerBase
 
         if (string.IsNullOrWhiteSpace(option.Name) && option.ShortName is null)
         {
-            context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+            context.ReportDiagnostic(
+                CreateDiagnostic(propertyDeclaration.Identifier.GetLocation())
+            );
         }
     }
 

CliFx.Analyzers/OptionMustHaveUniqueNameAnalyzer.cs

@@ -14,7 +14,9 @@ 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}`.")
     {
     }
 
@@ -37,7 +39,7 @@ public class OptionMustHaveUniqueNameAnalyzer : AnalyzerBase
             .ContainingType
             .GetMembers()
             .OfType<IPropertySymbol>()
-            .Where(m => !m.Equals(property, SymbolEqualityComparer.Default))
+            .Where(m => !m.Equals(property))
             .ToArray();
 
         foreach (var otherProperty in otherProperties)
@@ -51,7 +53,13 @@ public class OptionMustHaveUniqueNameAnalyzer : AnalyzerBase
 
             if (string.Equals(option.Name, otherOption.Name, StringComparison.OrdinalIgnoreCase))
             {
-                context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+                context.ReportDiagnostic(
+                    CreateDiagnostic(
+                        propertyDeclaration.Identifier.GetLocation(),
+                        option.Name,
+                        otherProperty.Name
+                    )
+                );
             }
         }
     }

CliFx.Analyzers/OptionMustHaveUniqueShortNameAnalyzer.cs

@@ -13,7 +13,9 @@ 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}`.")
     {
     }
 
@@ -36,7 +38,7 @@ public class OptionMustHaveUniqueShortNameAnalyzer : AnalyzerBase
             .ContainingType
             .GetMembers()
             .OfType<IPropertySymbol>()
-            .Where(m => !m.Equals(property, SymbolEqualityComparer.Default))
+            .Where(m => !m.Equals(property))
             .ToArray();
 
         foreach (var otherProperty in otherProperties)
@@ -50,7 +52,13 @@ public class OptionMustHaveUniqueShortNameAnalyzer : AnalyzerBase
 
             if (option.ShortName == otherOption.ShortName)
             {
-                context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+                context.ReportDiagnostic(
+                    CreateDiagnostic(
+                        propertyDeclaration.Identifier.GetLocation(),
+                        option.ShortName,
+                        otherProperty.Name
+                    )
+                );
             }
         }
     }

CliFx.Analyzers/OptionMustHaveValidConverterAnalyzer.cs

@@ -13,7 +13,7 @@ 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 @@ public class OptionMustHaveValidConverterAnalyzer : AnalyzerBase
         if (option.ConverterType is null)
             return;
 
-        // We check against an internal interface because checking against a generic class is a pain
+        var converterValueType = option
-        var converterImplementsInterface = option
             .ConverterType
-            .AllInterfaces
+            .GetBaseTypes()
-            .Any(s => s.DisplayNameMatches(SymbolNames.CliFxBindingConverterInterface));
+            .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())
+            );
         }
     }
 

CliFx.Analyzers/OptionMustHaveValidNameAnalyzer.cs

@@ -12,7 +12,8 @@ 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 @@ public class OptionMustHaveValidNameAnalyzer : AnalyzerBase
 
         if (option.Name.Length < 2 || !char.IsLetter(option.Name[0]))
         {
-            context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+            context.ReportDiagnostic(
+                CreateDiagnostic(
+                    propertyDeclaration.Identifier.GetLocation(),
+                    option.Name
+                )
+            );
         }
     }
 

CliFx.Analyzers/OptionMustHaveValidShortNameAnalyzer.cs

@@ -12,7 +12,8 @@ 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 @@ public class OptionMustHaveValidShortNameAnalyzer : AnalyzerBase
 
         if (!char.IsLetter(option.ShortName.Value))
         {
-            context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+            context.ReportDiagnostic(
+                CreateDiagnostic(
+                    propertyDeclaration.Identifier.GetLocation(),
+                    option.ShortName
+                )
+            );
         }
     }
 

CliFx.Analyzers/OptionMustHaveValidValidatorsAnalyzer.cs

@@ -13,7 +13,7 @@ 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 @@ public class OptionMustHaveValidValidatorsAnalyzer : AnalyzerBase
 
         foreach (var validatorType in option.ValidatorTypes)
         {
-            // We check against an internal interface because checking against a generic class is a pain
+            var validatorValueType = validatorType
-            var validatorImplementsInterface = validatorType
+                .GetBaseTypes()
-                .AllInterfaces
+                .FirstOrDefault(t => t.ConstructedFrom.DisplayNameMatches(SymbolNames.CliFxBindingValidatorClass))?
-                .Any(s => s.DisplayNameMatches(SymbolNames.CliFxBindingValidatorInterface));
+                .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;

CliFx.Analyzers/ParameterMustBeInsideCommandAnalyzer.cs

@@ -34,11 +34,13 @@ public class ParameterMustBeInsideCommandAnalyzer : AnalyzerBase
         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())
+            );
         }
     }
 

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

@@ -12,18 +12,12 @@ public class ParameterMustBeLastIfNonScalarAnalyzer : AnalyzerBase
 {
     public ParameterMustBeLastIfNonScalarAnalyzer()
         : base(
-            "Parameters of non-scalar types must be last in order",
+            "Parameters of non-scalar types must be the 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).")
+            "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,
@@ -32,18 +26,18 @@ public class ParameterMustBeLastIfNonScalarAnalyzer : AnalyzerBase
         if (property.ContainingType is null)
             return;
 
-        if (IsScalar(property.Type))
-            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)
@@ -54,7 +48,12 @@ public class ParameterMustBeLastIfNonScalarAnalyzer : AnalyzerBase
 
             if (otherParameter.Order > parameter.Order)
             {
-                context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+                context.ReportDiagnostic(
+                    CreateDiagnostic(
+                        propertyDeclaration.Identifier.GetLocation(),
+                        otherProperty.Name
+                    )
+                );
             }
         }
     }

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

@@ -13,17 +13,11 @@ 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,
@@ -32,27 +26,34 @@ public class ParameterMustBeSingleIfNonScalarAnalyzer : AnalyzerBase
         if (property.ContainingType is null)
             return;
 
-        if (!CommandParameterSymbol.IsParameterProperty(property))
+        var parameter = CommandParameterSymbol.TryResolve(property);
+        if (parameter is null)
             return;
 
-        if (IsScalar(property.Type))
+        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
+                    )
+                );
             }
         }
     }

CliFx.Analyzers/ParameterMustHaveUniqueNameAnalyzer.cs

@@ -14,7 +14,9 @@ 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}`.")
     {
     }
 
@@ -37,7 +39,7 @@ public class ParameterMustHaveUniqueNameAnalyzer : AnalyzerBase
             .ContainingType
             .GetMembers()
             .OfType<IPropertySymbol>()
-            .Where(m => !m.Equals(property, SymbolEqualityComparer.Default))
+            .Where(m => !m.Equals(property))
             .ToArray();
 
         foreach (var otherProperty in otherProperties)
@@ -51,7 +53,13 @@ public class ParameterMustHaveUniqueNameAnalyzer : AnalyzerBase
 
             if (string.Equals(parameter.Name, otherParameter.Name, StringComparison.OrdinalIgnoreCase))
             {
-                context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+                context.ReportDiagnostic(
+                    CreateDiagnostic(
+                        propertyDeclaration.Identifier.GetLocation(),
+                        parameter.Name,
+                        otherProperty.Name
+                    )
+                );
             }
         }
     }

CliFx.Analyzers/ParameterMustHaveUniqueOrderAnalyzer.cs

@@ -13,7 +13,9 @@ 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}`.")
     {
     }
 
@@ -33,7 +35,7 @@ public class ParameterMustHaveUniqueOrderAnalyzer : AnalyzerBase
             .ContainingType
             .GetMembers()
             .OfType<IPropertySymbol>()
-            .Where(m => !m.Equals(property, SymbolEqualityComparer.Default))
+            .Where(m => !m.Equals(property))
             .ToArray();
 
         foreach (var otherProperty in otherProperties)
@@ -44,7 +46,13 @@ public class ParameterMustHaveUniqueOrderAnalyzer : AnalyzerBase
 
             if (parameter.Order == otherParameter.Order)
             {
-                context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+                context.ReportDiagnostic(
+                    CreateDiagnostic(
+                        propertyDeclaration.Identifier.GetLocation(),
+                        parameter.Order,
+                        otherProperty.Name
+                    )
+                );
             }
         }
     }

CliFx.Analyzers/ParameterMustHaveValidConverterAnalyzer.cs

@@ -13,7 +13,7 @@ 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 @@ public class ParameterMustHaveValidConverterAnalyzer : AnalyzerBase
         if (parameter.ConverterType is null)
             return;
 
-        // We check against an internal interface because checking against a generic class is a pain
+        var converterValueType = parameter
-        var converterImplementsInterface = parameter
             .ConverterType
-            .AllInterfaces
+            .GetBaseTypes()
-            .Any(s => s.DisplayNameMatches(SymbolNames.CliFxBindingConverterInterface));
+            .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())
+            );
         }
     }
 

CliFx.Analyzers/ParameterMustHaveValidValidatorsAnalyzer.cs

@@ -13,7 +13,7 @@ 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 @@ public class ParameterMustHaveValidValidatorsAnalyzer : AnalyzerBase
 
         foreach (var validatorType in parameter.ValidatorTypes)
         {
-            // We check against an internal interface because checking against a generic class is a pain
+            var validatorValueType = validatorType
-            var validatorImplementsInterface = validatorType
+                .GetBaseTypes()
-                .AllInterfaces
+                .FirstOrDefault(t => t.ConstructedFrom.DisplayNameMatches(SymbolNames.CliFxBindingValidatorClass))?
-                .Any(s => s.DisplayNameMatches(SymbolNames.CliFxBindingValidatorInterface));
+                .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;

CliFx.Analyzers/SystemConsoleShouldBeAvoidedAnalyzer.cs

@@ -65,7 +65,9 @@ public class SystemConsoleShouldBeAvoidedAnalyzer : AnalyzerBase
 
         if (isConsoleInterfaceAvailable)
         {
-            context.ReportDiagnostic(CreateDiagnostic(systemConsoleMemberAccess.GetLocation()));
+            context.ReportDiagnostic(
+                CreateDiagnostic(systemConsoleMemberAccess.GetLocation())
+            );
         }
     }
 

CliFx.Analyzers/Utils/Extensions/RoslynExtensions.cs

@@ -1,4 +1,6 @@
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
@@ -16,6 +18,36 @@ internal static class RoslynExtensions
             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> analyze)

CliFx.Analyzers/Utils/Extensions/StringExtensions.cs

@@ -10,7 +10,7 @@ internal static class StringExtensions
         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/CliFx.Benchmarks.csproj

@@ -2,16 +2,16 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net7.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="BenchmarkDotNet" Version="0.13.1" />
+    <PackageReference Include="BenchmarkDotNet" Version="0.13.5" />
     <PackageReference Include="clipr" Version="1.6.1" />
-    <PackageReference Include="Cocona" Version="1.6.0" />
+    <PackageReference Include="Cocona" Version="2.2.0" />
-    <PackageReference Include="CommandLineParser" Version="2.8.0" />
+    <PackageReference Include="CommandLineParser" Version="2.9.1" />
-    <PackageReference Include="McMaster.Extensions.CommandLineUtils" Version="3.1.0" />
+    <PackageReference Include="McMaster.Extensions.CommandLineUtils" Version="4.0.2" />
-    <PackageReference Include="PowerArgs" Version="3.6.0" />
+    <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>net6.0</TargetFramework>
+    <TargetFramework>net7.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="6.0.0" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="7.0.0" />
-    <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
   </ItemGroup>
 
   <ItemGroup>
     <ProjectReference Include="..\CliFx\CliFx.csproj" />
-    <ProjectReference Include="..\CliFx.Analyzers\CliFx.Analyzers.csproj" ReferenceOutputAssembly="false" OutputItemType="Analyzer" />
+    <ProjectReference Include="..\CliFx.Analyzers\CliFx.Analyzers.csproj" ReferenceOutputAssembly="false" OutputItemType="analyzer" />
   </ItemGroup>
 
 </Project>

CliFx.Demo/Commands/BookAddCommand.cs

@@ -14,10 +14,10 @@ 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.")]
+    [CommandOption("author", 'a', 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();

CliFx.Demo/Commands/BookCommand.cs

@@ -13,7 +13,7 @@ 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)
     {

CliFx.Demo/Commands/BookRemoveCommand.cs

@@ -12,7 +12,7 @@ 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)
     {

CliFx.Demo/Domain/Book.cs

@@ -2,21 +2,4 @@
 
 namespace CliFx.Demo.Domain;
 
-public class Book
+public record Book(string Title, string Author, DateTimeOffset Published, Isbn Isbn);
-{
-    public string Title { get; }
-
-    public string Author { get; }
-
-    public DateTimeOffset Published { get; }
-
-    public Isbn Isbn { get; }
-
-    public Book(string title, string author, DateTimeOffset published, Isbn isbn)
-    {
-        Title = title;
-        Author = author;
-        Published = published;
-        Isbn = isbn;
-    }
-}

CliFx.Demo/Domain/Isbn.cs

@@ -2,32 +2,13 @@
 
 namespace CliFx.Demo.Domain;
 
-public partial class Isbn
+public partial record Isbn(int EanPrefix, int RegistrationGroup, int Registrant, int Publication, int CheckDigit)
 {
-    public int EanPrefix { get; }
-
-    public int RegistrationGroup { get; }
-
-    public int Registrant { get; }
-
-    public int Publication { get; }
-
-    public int CheckDigit { get; }
-
-    public Isbn(int eanPrefix, int registrationGroup, int registrant, int publication, int checkDigit)
-    {
-        EanPrefix = eanPrefix;
-        RegistrationGroup = registrationGroup;
-        Registrant = registrant;
-        Publication = publication;
-        CheckDigit = checkDigit;
-    }
-
     public override string ToString() =>
         $"{EanPrefix:000}-{RegistrationGroup:00}-{Registrant:00000}-{Publication:00}-{CheckDigit:0}";
 }
 
-public partial class Isbn
+public partial record Isbn
 {
     public static Isbn Parse(string value, IFormatProvider formatProvider)
     {

CliFx.Demo/Domain/Library.cs

@@ -4,15 +4,8 @@ using System.Linq;
 
 namespace CliFx.Demo.Domain;
 
-public partial class Library
+public partial record Library(IReadOnlyList<Book> Books)
 {
-    public IReadOnlyList<Book> Books { get; }
-
-    public Library(IReadOnlyList<Book> books)
-    {
-        Books = books;
-    }
-
     public Library WithBook(Book book)
     {
         var books = Books.ToList();
@@ -29,7 +22,7 @@ public partial class Library
     }
 }
 
-public partial class Library
+public partial record Library
 {
     public static Library Empty { get; } = new(Array.Empty<Book>());
 }

CliFx.Demo/Domain/LibraryProvider.cs

@@ -1,6 +1,6 @@
 using System.IO;
 using System.Linq;
-using Newtonsoft.Json;
+using System.Text.Json;
 
 namespace CliFx.Demo.Domain;
 
@@ -10,7 +10,7 @@ public class LibraryProvider
 
     private void StoreLibrary(Library library)
     {
-        var data = JsonConvert.SerializeObject(library);
+        var data = JsonSerializer.Serialize(library);
         File.WriteAllText(StorageFilePath, data);
     }
 
@@ -21,7 +21,7 @@ public class LibraryProvider
 
         var data = File.ReadAllText(StorageFilePath);
 
-        return JsonConvert.DeserializeObject<Library>(data) ?? Library.Empty;
+        return JsonSerializer.Deserialize<Library>(data) ?? Library.Empty;
     }
 
     public Book? TryGetBook(string title) => GetLibrary().Books.FirstOrDefault(b => b.Title == title);

CliFx.Demo/Program.cs

@@ -1,25 +1,21 @@
 using CliFx;
-using CliFx.Demo.Commands;
 using CliFx.Demo.Domain;
 using Microsoft.Extensions.DependencyInjection;
 
-// We use Microsoft.Extensions.DependencyInjection for injecting dependencies in commands
-var services = new ServiceCollection();
-
-// Register services
-services.AddSingleton<LibraryProvider>();
-
-// Register commands
-services.AddTransient<BookCommand>();
-services.AddTransient<BookAddCommand>();
-services.AddTransient<BookRemoveCommand>();
-services.AddTransient<BookListCommand>();
-
-var serviceProvider = services.BuildServiceProvider();
-
 return await new CliApplicationBuilder()
     .SetDescription("Demo application showcasing CliFx features.")
     .AddCommandsFromThisAssembly()
-    .UseTypeActivator(serviceProvider.GetRequiredService)
+    .UseTypeActivator(commandTypes =>
+    {
+        // We use Microsoft.Extensions.DependencyInjection for injecting dependencies in commands
+        var services = new ServiceCollection();
+        services.AddSingleton<LibraryProvider>();
+
+        // Register all commands as transient services
+        foreach (var commandType in commandTypes)
+            services.AddTransient(commandType);
+
+        return services.BuildServiceProvider();
+    })
     .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.Tests.Dummy/CliFx.Tests.Dummy.csproj

@@ -2,12 +2,12 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net6.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/CancellationTestCommand.cs

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

CliFx.Tests.Dummy/Commands/EnvironmentTestCommand.cs

@@ -8,7 +8,7 @@ namespace CliFx.Tests.Dummy.Commands;
 public class EnvironmentTestCommand : ICommand
 {
     [CommandOption("target", EnvironmentVariable = "ENV_TARGET")]
-    public string GreetingTarget { get; set; } = "World";
+    public string GreetingTarget { get; init; } = "World";
 
     public ValueTask ExecuteAsync(IConsole console)
     {

CliFx.Tests.Dummy/Program.cs

@@ -1,22 +1,30 @@
-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.
 
+// This dummy application is used in tests for scenarios that require an external process to properly verify
 public static partial class Program
 {
-    public static Assembly Assembly { get; } = typeof(Program).Assembly;
+    public static Assembly Assembly { get; } = Assembly.GetExecutingAssembly();
 
     public static string Location { get; } = Assembly.Location;
 }
 
 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()
             .RunAsync();
+    }
 }

CliFx.Tests/ApplicationSpecs.cs

@@ -16,7 +16,7 @@ public class ApplicationSpecs : SpecsBase
     }
 
     [Fact]
-    public async Task Application_can_be_created_with_minimal_configuration()
+    public async Task I_can_create_an_application_with_the_default_configuration()
     {
         // Act
         var app = new CliApplicationBuilder()
@@ -34,7 +34,7 @@ public class ApplicationSpecs : SpecsBase
     }
 
     [Fact]
-    public async Task Application_can_be_created_with_a_fully_customized_configuration()
+    public async Task I_can_create_an_application_with_a_custom_configuration()
     {
         // Act
         var app = new CliApplicationBuilder()
@@ -63,7 +63,7 @@ public class ApplicationSpecs : SpecsBase
     }
 
     [Fact]
-    public async Task Application_configuration_fails_if_an_invalid_command_is_registered()
+    public async Task I_cannot_add_an_invalid_command_to_the_application()
     {
         // Act
         var app = new CliApplicationBuilder()
@@ -76,10 +76,10 @@ public class ApplicationSpecs : SpecsBase
             new Dictionary<string, string>()
         );
 
-        var stdErr = FakeConsole.ReadErrorString();
-
         // Assert
         exitCode.Should().NotBe(0);
+
+        var stdErr = FakeConsole.ReadErrorString();
         stdErr.Should().Contain("not a valid command");
     }
 }

CliFx.Tests/CancellationSpecs.cs

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

CliFx.Tests/CliFx.Tests.csproj

@@ -1,11 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net7.0</TargetFramework>
-    <IsPackable>false</IsPackable>
-    <IsTestProject>true</IsTestProject>
-    <CollectCoverage>true</CollectCoverage>
-    <CoverletOutputFormat>opencover</CoverletOutputFormat>
   </PropertyGroup>
 
   <ItemGroup>
@@ -13,15 +9,16 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Basic.Reference.Assemblies" Version="1.2.4" />
+    <PackageReference Include="Basic.Reference.Assemblies.Net70" Version="1.4.2" />
-    <PackageReference Include="CliWrap" Version="3.3.3" />
+    <PackageReference Include="CliWrap" Version="3.6.1" />
-    <PackageReference Include="FluentAssertions" Version="6.2.0" />
+    <PackageReference Include="FluentAssertions" Version="6.11.0" />
-    <PackageReference Include="GitHubActionsTestLogger" Version="1.2.0" />
+    <PackageReference Include="GitHubActionsTestLogger" Version="2.2.0" PrivateAssets="all" />
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.0.1" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.6.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.0.0" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="7.0.0" />
-    <PackageReference Include="xunit" Version="2.4.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.6.0" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3" PrivateAssets="all" />
+    <PackageReference Include="xunit" Version="2.4.2" />
-    <PackageReference Include="coverlet.msbuild" Version="3.1.0" PrivateAssets="all" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5" PrivateAssets="all" />
+    <PackageReference Include="coverlet.collector" Version="3.2.0" PrivateAssets="all" />
   </ItemGroup>
 
   <ItemGroup>
@@ -29,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

@@ -5,6 +5,7 @@ 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;
@@ -20,17 +21,17 @@ public class ConsoleSpecs : SpecsBase
     {
     }
 
-    [Fact]
+    [Fact(Timeout = 15000)]
-    public async Task Real_console_maps_directly_to_system_console()
+    public async Task I_can_run_the_application_with_the_default_console_implementation_to_interact_with_the_system_console()
     {
-        // Can't verify our own console output, so using an
+        // Can't verify our own console output, so using an external process for this test
-        // external process for this test.
 
         // Arrange
         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();
@@ -41,30 +42,52 @@ public class ConsoleSpecs : SpecsBase
     }
 
     [Fact]
-    public async Task Fake_console_does_not_leak_to_system_console()
+    public void I_can_run_the_application_on_a_system_with_a_custom_console_encoding_and_not_get_corrupted_output()
+    {
+        // Arrange
+        using var buffer = new MemoryStream();
+        using var consoleWriter = new ConsoleWriter(FakeConsole, buffer, Encoding.UTF8);
+
+        // Act
+        consoleWriter.Write("Hello world");
+        consoleWriter.Flush();
+
+        // Assert
+        var outputBytes = buffer.ToArray();
+        outputBytes.Should().NotContain(Encoding.UTF8.GetPreamble());
+
+        var output = consoleWriter.Encoding.GetString(outputBytes);
+        output.Should().Be("Hello world");
+    }
+
+    [Fact]
+    public async Task I_can_run_the_application_with_the_fake_console_implementation_to_isolate_console_interactions()
     {
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{   
+            {
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        console.ResetColor();
+                    console.ResetColor();
-        console.ForegroundColor = ConsoleColor.DarkMagenta;
+                    console.ForegroundColor = ConsoleColor.DarkMagenta;
-        console.BackgroundColor = ConsoleColor.DarkMagenta;
+                    console.BackgroundColor = ConsoleColor.DarkMagenta;
-        console.CursorLeft = 42;
+                    console.WindowWidth = 100;
-        console.CursorTop = 24;
+                    console.WindowHeight = 25;
+                    console.CursorLeft = 42;
+                    console.CursorTop = 24;
 
-        console.Output.WriteLine(""Hello "");
+                    console.Output.WriteLine("Hello ");
-        console.Error.WriteLine(""world!"");
+                    console.Error.WriteLine("world!");
 
-        return default;
+                    return default;
-    }
+                }
-}
+            }
-");
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -88,6 +111,8 @@ public class Command : ICommand
         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);
 
@@ -97,25 +122,26 @@ public class Command : ICommand
     }
 
     [Fact]
-    public async Task Fake_console_can_be_used_with_an_in_memory_backing_store()
+    public async Task I_can_run_the_application_with_the_fake_console_implementation_and_simulate_stream_interactions()
     {
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{   
+            {
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        var input = console.Input.ReadToEnd();
+                    var input = console.Input.ReadToEnd();
-        console.Output.WriteLine(input);
+                    console.Output.WriteLine(input);
-        console.Error.WriteLine(input);
+                    console.Error.WriteLine(input);
 
-        return default;
+                    return default;
-    }
+                }
-}
+            }
-");
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -130,29 +156,61 @@ public class Command : ICommand
             new Dictionary<string, string>()
         );
 
-        var stdOut = FakeConsole.ReadOutputString();
-        var stdErr = FakeConsole.ReadErrorString();
-
         // Assert
         exitCode.Should().Be(0);
+
+        var stdOut = FakeConsole.ReadOutputString();
         stdOut.Trim().Should().Be("Hello world");
+
+        var stdErr = FakeConsole.ReadErrorString();
         stdErr.Trim().Should().Be("Hello world");
     }
 
     [Fact]
-    public void Console_does_not_emit_preamble_when_used_with_encoding_that_has_it()
+    public async Task I_can_run_the_application_with_the_fake_console_implementation_and_simulate_key_presses()
     {
         // Arrange
-        using var buffer = new MemoryStream();
+        var commandType = DynamicCommandBuilder.Compile(
-        using var consoleWriter = new ConsoleWriter(FakeConsole, buffer, Encoding.UTF8);
+            // 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
-        consoleWriter.Write("Hello world");
+        FakeConsole.EnqueueKey(new ConsoleKeyInfo('0', ConsoleKey.D0, false, false, false));
-        consoleWriter.Flush();
+        FakeConsole.EnqueueKey(new ConsoleKeyInfo('a', ConsoleKey.A, false, false, false));
+        FakeConsole.EnqueueKey(new ConsoleKeyInfo('\0', ConsoleKey.Backspace, false, false, false));
 
-        var output = consoleWriter.Encoding.GetString(buffer.ToArray());
+        var exitCode = await application.RunAsync(
+            Array.Empty<string>(),
+            new Dictionary<string, string>()
+        );
 
         // Assert
-        output.Should().Be("Hello world");
+        exitCode.Should().Be(0);
+
+        var stdOut = FakeConsole.ReadOutputString();
+        stdOut.Trim().Should().ConsistOfLines(
+            "D0",
+            "A",
+            "Backspace"
+        );
     }
 }

CliFx.Tests/DirectivesSpecs.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using CliFx.Tests.Utils;
@@ -19,68 +18,51 @@ public class DirectivesSpecs : SpecsBase
     {
     }
 
-    [Fact]
+    [Fact(Timeout = 15000)]
-    public async Task Debug_directive_can_be_specified_to_interrupt_execution_until_a_debugger_is_attached()
+    public async Task I_can_use_the_debug_directive_to_make_the_application_wait_for_the_debugger_to_attach()
     {
         // 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 the 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
+            await command.ExecuteAsync(cts.Token);
-            using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
-
-            var task = command.ExecuteAsync(cts.Token);
-
-            // We can't attach a debugger programmatically, so the application
-            // will hang indefinitely.
-            // To work around it, we will wait until the application writes
-            // something to the standard output and then kill it.
-            while (true)
-            {
-                if (stdOutBuffer.Length > 0)
-                {
-                    cts.Cancel();
-                    break;
-                }
-
-                await Task.Delay(100, cts.Token);
-            }
-
-            await task;
         }
-        catch (OperationCanceledException)
+        catch (OperationCanceledException ex) when (ex.CancellationToken == cts.Token)
         {
-            // It's expected to fail
+            // This means that the process was killed after it wrote the expected output
         }
-
-        var stdOut = stdOutBuffer.ToString();
-
-        // Assert
-        stdOut.Should().Contain("Attach debugger to");
-
-        TestOutput.WriteLine(stdOut);
     }
 
     [Fact]
-    public async Task Preview_directive_can_be_specified_to_print_command_input()
+    public async Task I_can_use_the_preview_directive_to_make_the_application_print_the_parsed_command_input()
     {
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command(""cmd"")]
+            [Command("cmd")]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                public ValueTask ExecuteAsync(IConsole console) => default;
-}
+            }
-");
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -98,10 +80,10 @@ public class Command : ICommand
             }
         );
 
-        var stdOut = FakeConsole.ReadOutputString();
-
         // Assert
         exitCode.Should().Be(0);
+
+        var stdOut = FakeConsole.ReadOutputString();
         stdOut.Should().ContainAllInOrder(
             "cmd", "<param>", "[-a]", "[-b]", "[-c]", "[--option \"foo\"]",
             "ENV_QOP", "=", "\"hello\"",

CliFx.Tests/EnvironmentSpecs.cs

@@ -20,25 +20,31 @@ public class EnvironmentSpecs : SpecsBase
     }
 
     [Fact]
-    public async Task Option_can_fall_back_to_an_environment_variable()
+    public async Task I_can_configure_an_option_to_fall_back_to_an_environment_variable_if_the_user_does_not_provide_the_corresponding_argument()
     {
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandOption(""foo"", IsRequired = true, EnvironmentVariable = ""ENV_FOO"")]
+                [CommandOption("foo", EnvironmentVariable = "ENV_FOO")]
-    public string Foo { get; set; }
+                public string? Foo { get; init; }
-    
+
-    public ValueTask ExecuteAsync(IConsole console)
+                [CommandOption("bar", EnvironmentVariable = "ENV_BAR")]
-    {
+                public string? Bar { get; init; }
-        console.Output.WriteLine(Foo);
+
-        return default;
+                public ValueTask ExecuteAsync(IConsole console)
-    }
+                {
-}
+                    console.Output.WriteLine(Foo);
-");
+                    console.Output.WriteLine(Bar);
+
+                    return default;
+                }
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -47,85 +53,48 @@ public class Command : ICommand
 
         // Act
         var exitCode = await application.RunAsync(
-            Array.Empty<string>(),
+            new[] {"--foo", "42"},
             new Dictionary<string, string>
             {
-                ["ENV_FOO"] = "bar"
+                ["ENV_FOO"] = "100",
+                ["ENV_BAR"] = "200"
             }
         );
 
-        var stdOut = FakeConsole.ReadOutputString();
-
         // Assert
         exitCode.Should().Be(0);
-        stdOut.Trim().Should().Be("bar");
+
+        var stdOut = FakeConsole.ReadOutputString();
+        stdOut.Trim().Should().ConsistOfLines(
+            "42",
+            "200"
+        );
     }
 
     [Fact]
-    public async Task Option_does_not_fall_back_to_an_environment_variable_if_a_value_is_provided_through_arguments()
+    public async Task I_can_configure_an_option_bound_to_a_non_scalar_property_to_fall_back_to_an_environment_variable_if_the_user_does_not_provide_the_corresponding_argument()
     {
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
-    [CommandOption(""foo"", EnvironmentVariable = ""ENV_FOO"")]
-    public string Foo { get; set; }
-    
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(Foo);
-        return default;
-    }
-}
-");
-
-        var application = new CliApplicationBuilder()
-            .AddCommand(commandType)
-            .UseConsole(FakeConsole)
-            .Build();
-
-        // Act
-        var exitCode = await application.RunAsync(
-            new[] {"--foo", "baz"},
-            new Dictionary<string, string>
             {
-                ["ENV_FOO"] = "bar"
+                [CommandOption("foo", EnvironmentVariable = "ENV_FOO")]
+                public IReadOnlyList<string>? Foo { get; init; }
+
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    foreach (var i in Foo)
+                        console.Output.WriteLine(i);
+
+                    return default;
+                }
             }
+            """
         );
 
-        var stdOut = FakeConsole.ReadOutputString();
-
-        // Assert
-        exitCode.Should().Be(0);
-        stdOut.Trim().Should().Be("baz");
-    }
-
-    [Fact]
-    public async Task Option_of_non_scalar_type_can_receive_multiple_values_from_an_environment_variable()
-    {
-        // Arrange
-        var commandType = DynamicCommandBuilder.Compile(
-            // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""foo"", EnvironmentVariable = ""ENV_FOO"")]
-    public IReadOnlyList<string> Foo { get; set; }
-    
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        foreach (var i in Foo)
-            console.Output.WriteLine(i);
-        
-        return default;
-    }
-}
-");
-
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -140,10 +109,10 @@ public class Command : ICommand
             }
         );
 
-        var stdOut = FakeConsole.ReadOutputString();
-
         // Assert
         exitCode.Should().Be(0);
+
+        var stdOut = FakeConsole.ReadOutputString();
         stdOut.Should().ConsistOfLines(
             "bar",
             "baz"
@@ -151,25 +120,26 @@ public class Command : ICommand
     }
 
     [Fact]
-    public async Task Option_of_scalar_type_always_receives_a_single_value_from_an_environment_variable()
+    public async Task I_can_configure_an_option_bound_to_a_scalar_property_to_fall_back_to_an_environment_variable_while_ignoring_path_separators()
     {
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandOption(""foo"", EnvironmentVariable = ""ENV_FOO"")]
+                [CommandOption("foo", EnvironmentVariable = "ENV_FOO")]
-    public string Foo { get; set; }
+                public string? Foo { get; init; }
-    
+
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        console.Output.WriteLine(Foo);
+                    console.Output.WriteLine(Foo);
-        return default;
+                    return default;
-    }
+                }
-}
+            }
-");
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -185,59 +155,15 @@ public class Command : ICommand
             }
         );
 
-        var stdOut = FakeConsole.ReadOutputString();
-
         // Assert
         exitCode.Should().Be(0);
+
+        var stdOut = FakeConsole.ReadOutputString();
         stdOut.Trim().Should().Be($"bar{Path.PathSeparator}baz");
     }
 
-    [Fact]
+    [Fact(Timeout = 15000)]
-    public async Task Environment_variables_are_matched_case_sensitively()
+    public async Task I_can_run_the_application_and_it_will_resolve_all_required_environment_variables_automatically()
-    {
-        // Arrange
-        var commandType = DynamicCommandBuilder.Compile(
-            // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""foo"", EnvironmentVariable = ""ENV_FOO"")]
-    public string Foo { get; set; }
-    
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(Foo);
-        return default;
-    }
-}
-");
-
-        var application = new CliApplicationBuilder()
-            .AddCommand(commandType)
-            .UseConsole(FakeConsole)
-            .Build();
-
-        // Act
-        var exitCode = await application.RunAsync(
-            Array.Empty<string>(),
-            new Dictionary<string, string>
-            {
-                ["ENV_foo"] = "baz",
-                ["ENV_FOO"] = "bar",
-                ["env_FOO"] = "qop"
-            }
-        );
-
-        var stdOut = FakeConsole.ReadOutputString();
-
-        // Assert
-        exitCode.Should().Be(0);
-        stdOut.Trim().Should().Be("bar");
-    }
-
-    [Fact]
-    public async Task Environment_variables_are_extracted_automatically()
     {
         // Ensures that the environment variables are properly obtained from
         // System.Environment when they are not provided explicitly to CliApplication.
@@ -246,9 +172,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();

CliFx.Tests/ErrorReportingSpecs.cs

@@ -17,19 +17,20 @@ public class ErrorReportingSpecs : SpecsBase
     }
 
     [Fact]
-    public async Task Command_can_throw_an_exception_which_exits_with_a_stacktrace()
+    public async Task I_can_throw_an_exception_in_a_command_to_report_an_error_with_a_stacktrace()
     {
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    public ValueTask ExecuteAsync(IConsole console) =>
+                public ValueTask ExecuteAsync(IConsole console) =>
-        throw new Exception(""Something went wrong"");
+                    throw new Exception("Something went wrong");
-}
+            }
-");
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -42,12 +43,13 @@ public class Command : ICommand
             new Dictionary<string, string>()
         );
 
-        var stdOut = FakeConsole.ReadOutputString();
-        var stdErr = FakeConsole.ReadErrorString();
-
         // Assert
         exitCode.Should().NotBe(0);
+
+        var stdOut = FakeConsole.ReadOutputString();
         stdOut.Should().BeEmpty();
+
+        var stdErr = FakeConsole.ReadErrorString();
         stdErr.Should().ContainAllInOrder(
             "System.Exception", "Something went wrong",
             "at", "CliFx."
@@ -55,19 +57,20 @@ public class Command : ICommand
     }
 
     [Fact]
-    public async Task Command_can_throw_an_exception_with_an_inner_exception_which_exits_with_a_stacktrace()
+    public async Task I_can_throw_an_exception_with_an_inner_exception_in_a_command_to_report_an_error_with_a_stacktrace()
     {
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    public ValueTask ExecuteAsync(IConsole console) =>
+                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)
@@ -80,12 +83,13 @@ public class Command : ICommand
             new Dictionary<string, string>()
         );
 
-        var stdOut = FakeConsole.ReadOutputString();
-        var stdErr = FakeConsole.ReadErrorString();
-
         // Assert
         exitCode.Should().NotBe(0);
+
+        var stdOut = FakeConsole.ReadOutputString();
         stdOut.Should().BeEmpty();
+
+        var stdErr = FakeConsole.ReadErrorString();
         stdErr.Should().ContainAllInOrder(
             "System.Exception", "Something went wrong",
             "System.Exception", "Another exception",
@@ -94,19 +98,20 @@ public class Command : ICommand
     }
 
     [Fact]
-    public async Task Command_can_throw_a_special_exception_which_exits_with_specified_code_and_message()
+    public async Task I_can_throw_an_exception_in_a_command_to_report_an_error_and_exit_with_the_specified_code()
     {
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    public ValueTask ExecuteAsync(IConsole console) =>
+                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)
@@ -119,29 +124,31 @@ public class Command : ICommand
             new Dictionary<string, string>()
         );
 
-        var stdOut = FakeConsole.ReadOutputString();
-        var stdErr = FakeConsole.ReadErrorString();
-
         // Assert
         exitCode.Should().Be(69);
+
+        var stdOut = FakeConsole.ReadOutputString();
         stdOut.Should().BeEmpty();
+
+        var stdErr = FakeConsole.ReadErrorString();
         stdErr.Trim().Should().Be("Something went wrong");
     }
 
     [Fact]
-    public async Task Command_can_throw_a_special_exception_without_message_which_exits_with_a_stacktrace()
+    public async Task I_can_throw_an_exception_without_a_message_in_a_command_to_report_an_error_with_a_stacktrace()
     {
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    public ValueTask ExecuteAsync(IConsole console) =>
+                public ValueTask ExecuteAsync(IConsole console) =>
-        throw new CommandException("""", 69);
+                    throw new CommandException("", 69);
-}
+            }
-");
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -154,12 +161,13 @@ public class Command : ICommand
             new Dictionary<string, string>()
         );
 
-        var stdOut = FakeConsole.ReadOutputString();
-        var stdErr = FakeConsole.ReadErrorString();
-
         // Assert
         exitCode.Should().Be(69);
+
+        var stdOut = FakeConsole.ReadOutputString();
         stdOut.Should().BeEmpty();
+
+        var stdErr = FakeConsole.ReadErrorString();
         stdErr.Should().ContainAllInOrder(
             "CliFx.Exceptions.CommandException",
             "at", "CliFx."
@@ -167,19 +175,20 @@ public class Command : ICommand
     }
 
     [Fact]
-    public async Task Command_can_throw_a_special_exception_which_prints_help_text_before_exiting()
+    public async Task I_can_throw_an_exception_in_a_command_to_report_an_error_and_print_the_help_text()
     {
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    public ValueTask ExecuteAsync(IConsole console) =>
+                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)
@@ -193,12 +202,13 @@ public class Command : ICommand
             new Dictionary<string, string>()
         );
 
-        var stdOut = FakeConsole.ReadOutputString();
-        var stdErr = FakeConsole.ReadErrorString();
-
         // Assert
         exitCode.Should().Be(69);
+
+        var stdOut = FakeConsole.ReadOutputString();
         stdOut.Should().Contain("This will be in help text");
+
+        var stdErr = FakeConsole.ReadErrorString();
         stdErr.Trim().Should().Be("Something went wrong");
     }
 }

CliFx.Tests/ParameterBindingSpecs.cs

@@ -16,29 +16,31 @@ public class ParameterBindingSpecs : SpecsBase
     }
 
     [Fact]
-    public async Task Parameter_is_bound_from_an_argument_matching_its_order()
+    public async Task I_can_bind_a_parameter_to_a_property_and_get_the_value_from_the_corresponding_argument()
     {
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandParameter(0)]
+                [CommandParameter(0)]
-    public string Foo { get; set; }
+                public required string Foo { get; init; }
-    
-    [CommandParameter(1)]
-    public string Bar { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
+                [CommandParameter(1)]
-    {
+                public required string Bar { get; init; }
-        console.Output.WriteLine(""Foo = "" + Foo);
+
-        console.Output.WriteLine(""Bar = "" + Bar);
+                public ValueTask ExecuteAsync(IConsole console)
-        
+                {
-        return default;
+                    console.Output.WriteLine("Foo = " + Foo);
-    }
+                    console.Output.WriteLine("Bar = " + Bar);
-}");
+
+                    return default;
+                }
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -51,10 +53,10 @@ public class Command : ICommand
             new Dictionary<string, string>()
         );
 
-        var stdOut = FakeConsole.ReadOutputString();
-
         // Assert
         exitCode.Should().Be(0);
+
+        var stdOut = FakeConsole.ReadOutputString();
         stdOut.Should().ConsistOfLines(
             "Foo = one",
             "Bar = two"
@@ -62,38 +64,40 @@ public class Command : ICommand
     }
 
     [Fact]
-    public async Task Parameter_of_non_scalar_type_is_bound_from_remaining_non_option_arguments()
+    public async Task I_can_bind_a_parameter_to_a_non_scalar_property_and_get_values_from_the_remaining_non_option_arguments()
     {
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandParameter(0)]
+                [CommandParameter(0)]
-    public string Foo { get; set; }
+                public required string Foo { get; init; }
-    
-    [CommandParameter(1)]
-    public string Bar { get; set; }
-    
-    [CommandParameter(2)]
-    public IReadOnlyList<string> Baz { get; set; }
-    
-    [CommandOption(""boo"")]
-    public string Boo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
+                [CommandParameter(1)]
-    {
+                public required string Bar { get; init; }
-        console.Output.WriteLine(""Foo = "" + Foo);
+
-        console.Output.WriteLine(""Bar = "" + Bar);
+                [CommandParameter(2)]
-        
+                public required IReadOnlyList<string> Baz { get; init; }
-        foreach (var i in Baz)
+
-            console.Output.WriteLine(""Baz = "" + i);
+                [CommandOption("boo")]
-        
+                public string? Boo { get; init; }
-        return default;
+
-    }
+                public ValueTask ExecuteAsync(IConsole console)
-}");
+                {
+                    console.Output.WriteLine("Foo = " + Foo);
+                    console.Output.WriteLine("Bar = " + Bar);
+
+                    foreach (var i in Baz)
+                        console.Output.WriteLine("Baz = " + i);
+
+                    return default;
+                }
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -106,10 +110,10 @@ public class Command : ICommand
             new Dictionary<string, string>()
         );
 
-        var stdOut = FakeConsole.ReadOutputString();
-
         // Assert
         exitCode.Should().Be(0);
+
+        var stdOut = FakeConsole.ReadOutputString();
         stdOut.Should().ConsistOfLines(
             "Foo = one",
             "Bar = two",
@@ -120,23 +124,25 @@ public class Command : ICommand
     }
 
     [Fact]
-    public async Task Parameter_binding_fails_if_one_of_the_parameters_has_not_been_provided()
+    public async Task I_can_bind_a_parameter_to_a_property_and_get_an_error_if_the_user_does_not_provide_the_corresponding_argument()
     {
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandParameter(0)]
+                [CommandParameter(0)]
-    public string Foo { get; set; }
+                public required string Foo { get; init; }
-    
-    [CommandParameter(1)]
-    public string Bar { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                [CommandParameter(1)]
-}");
+                public required string Bar { get; init; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -149,31 +155,33 @@ public class Command : ICommand
             new Dictionary<string, string>()
         );
 
-        var stdErr = FakeConsole.ReadErrorString();
-
         // Assert
         exitCode.Should().NotBe(0);
-        stdErr.Should().Contain("Missing parameter(s)");
+
+        var stdErr = FakeConsole.ReadErrorString();
+        stdErr.Should().Contain("Missing required parameter(s)");
     }
 
     [Fact]
-    public async Task Parameter_binding_fails_if_a_parameter_of_non_scalar_type_has_not_been_provided_with_at_least_one_value()
+    public async Task I_can_bind_a_parameter_to_a_non_scalar_property_and_get_an_error_if_the_user_does_not_provide_at_least_one_corresponding_argument()
     {
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandParameter(0)]
+                [CommandParameter(0)]
-    public string Foo { get; set; }
+                public required string Foo { get; init; }
-    
+
-    [CommandParameter(1)]
+                [CommandParameter(1)]
-    public IReadOnlyList<string> Bar { get; set; }
+                public required IReadOnlyList<string> Bar { get; init; }
-    
+
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                public ValueTask ExecuteAsync(IConsole console) => default;
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -186,31 +194,81 @@ public class Command : ICommand
             new Dictionary<string, string>()
         );
 
-        var stdErr = FakeConsole.ReadErrorString();
-
         // Assert
         exitCode.Should().NotBe(0);
-        stdErr.Should().Contain("Missing parameter(s)");
+
+        var stdErr = FakeConsole.ReadErrorString();
+        stdErr.Should().Contain("Missing required parameter(s)");
     }
 
     [Fact]
-    public async Task Parameter_binding_fails_if_one_of_the_provided_parameters_is_unexpected()
+    public async Task I_can_bind_a_non_required_parameter_to_a_property_and_get_no_value_if_the_user_does_not_provide_the_corresponding_argument()
     {
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandParameter(0)]
+                [CommandParameter(0)]
-    public string Foo { get; set; }
+                public required string Foo { get; init; }
-    
-    [CommandParameter(1)]
-    public string Bar { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                [CommandParameter(1, IsRequired = false)]
-}");
+                public string? Bar { get; init; } = "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>()
+        );
+
+        // Assert
+        exitCode.Should().Be(0);
+
+        var stdOut = FakeConsole.ReadOutputString();
+        stdOut.Should().ConsistOfLines(
+            "Foo = abc",
+            "Bar = xyz"
+        );
+    }
+
+    [Fact]
+    public async Task I_can_bind_parameters_and_get_an_error_if_the_user_provides_too_many_arguments()
+    {
+        // Arrange
+        var commandType = DynamicCommandBuilder.Compile(
+            // language=cs
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandParameter(0)]
+                public required string Foo { get; init; }
+
+                [CommandParameter(1)]
+                public required string Bar { get; init; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -223,10 +281,10 @@ public class Command : ICommand
             new Dictionary<string, string>()
         );
 
-        var stdErr = FakeConsole.ReadErrorString();
-
         // Assert
         exitCode.Should().NotBe(0);
+
+        var stdErr = FakeConsole.ReadErrorString();
         stdErr.Should().Contain("Unexpected parameter(s)");
     }
 }

CliFx.Tests/RoutingSpecs.cs

@@ -16,42 +16,43 @@ public class RoutingSpecs : SpecsBase
     }
 
     [Fact]
-    public async Task Default_command_is_executed_if_provided_arguments_do_not_match_any_named_command()
+    public async Task I_can_configure_a_command_to_be_executed_by_default_when_the_user_does_not_specify_a_command_name()
     {
         // Arrange
         var commandTypes = DynamicCommandBuilder.CompileMany(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class DefaultCommand : ICommand
+            public class DefaultCommand : ICommand
-{
+            {
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        console.Output.WriteLine(""default"");
+                    console.Output.WriteLine("default");
-        return default;
+                    return default;
-    }
+                }
-}
+            }
 
-[Command(""cmd"")]
+            [Command("cmd")]
-public class NamedCommand : ICommand
+            public class NamedCommand : ICommand
-{
+            {
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        console.Output.WriteLine(""cmd"");
+                    console.Output.WriteLine("cmd");
-        return default;
+                    return default;
-    }
+                }
-}
+            }
 
-[Command(""cmd child"")]
+            [Command("cmd child")]
-public class NamedChildCommand : ICommand
+            public class NamedChildCommand : ICommand
-{
+            {
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        console.Output.WriteLine(""cmd child"");
+                    console.Output.WriteLine("cmd child");
-        return default;
+                    return default;
-    }
+                }
-}
+            }
-");
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommands(commandTypes)
@@ -64,50 +65,51 @@ public class NamedChildCommand : ICommand
             new Dictionary<string, string>()
         );
 
-        var stdOut = FakeConsole.ReadOutputString();
-
         // Assert
         exitCode.Should().Be(0);
+
+        var stdOut = FakeConsole.ReadOutputString();
         stdOut.Trim().Should().Be("default");
     }
 
     [Fact]
-    public async Task Specific_named_command_is_executed_if_provided_arguments_match_its_name()
+    public async Task I_can_configure_a_command_to_be_executed_when_the_user_specifies_its_name()
     {
         // Arrange
         var commandTypes = DynamicCommandBuilder.CompileMany(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class DefaultCommand : ICommand
+            public class DefaultCommand : ICommand
-{
+            {
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        console.Output.WriteLine(""default"");
+                    console.Output.WriteLine("default");
-        return default;
+                    return default;
-    }
+                }
-}
+            }
 
-[Command(""cmd"")]
+            [Command("cmd")]
-public class NamedCommand : ICommand
+            public class NamedCommand : ICommand
-{
+            {
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        console.Output.WriteLine(""cmd"");
+                    console.Output.WriteLine("cmd");
-        return default;
+                    return default;
-    }
+                }
-}
+            }
 
-[Command(""cmd child"")]
+            [Command("cmd child")]
-public class NamedChildCommand : ICommand
+            public class NamedChildCommand : ICommand
-{
+            {
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        console.Output.WriteLine(""cmd child"");
+                    console.Output.WriteLine("cmd child");
-        return default;
+                    return default;
-    }
+                }
-}
+            }
-");
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommands(commandTypes)
@@ -120,50 +122,51 @@ public class NamedChildCommand : ICommand
             new Dictionary<string, string>()
         );
 
-        var stdOut = FakeConsole.ReadOutputString();
-
         // Assert
         exitCode.Should().Be(0);
+
+        var stdOut = FakeConsole.ReadOutputString();
         stdOut.Trim().Should().Be("cmd");
     }
 
     [Fact]
-    public async Task Specific_named_child_command_is_executed_if_provided_arguments_match_its_name()
+    public async Task I_can_configure_a_nested_command_to_be_executed_when_the_user_specifies_its_name()
     {
         // Arrange
         var commandTypes = DynamicCommandBuilder.CompileMany(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class DefaultCommand : ICommand
+            public class DefaultCommand : ICommand
-{
+            {
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        console.Output.WriteLine(""default"");
+                    console.Output.WriteLine("default");
-        return default;
+                    return default;
-    }
+                }
-}
+            }
 
-[Command(""cmd"")]
+            [Command("cmd")]
-public class NamedCommand : ICommand
+            public class NamedCommand : ICommand
-{
+            {
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        console.Output.WriteLine(""cmd"");
+                    console.Output.WriteLine("cmd");
-        return default;
+                    return default;
-    }
+                }
-}
+            }
 
-[Command(""cmd child"")]
+            [Command("cmd child")]
-public class NamedChildCommand : ICommand
+            public class NamedChildCommand : ICommand
-{
+            {
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        console.Output.WriteLine(""cmd child"");
+                    console.Output.WriteLine("cmd child");
-        return default;
+                    return default;
-    }
+                }
-}
+            }
-");
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommands(commandTypes)
@@ -176,10 +179,10 @@ public class NamedChildCommand : ICommand
             new Dictionary<string, string>()
         );
 
-        var stdOut = FakeConsole.ReadOutputString();
-
         // Assert
         exitCode.Should().Be(0);
+
+        var stdOut = FakeConsole.ReadOutputString();
         stdOut.Trim().Should().Be("cmd child");
     }
 }

CliFx.Tests/TypeActivationSpecs.cs

@@ -4,6 +4,7 @@ using System.Threading.Tasks;
 using CliFx.Infrastructure;
 using CliFx.Tests.Utils;
 using FluentAssertions;
+using Microsoft.Extensions.DependencyInjection;
 using Xunit;
 using Xunit.Abstractions;
 
@@ -17,21 +18,23 @@ public class TypeActivationSpecs : SpecsBase
     }
 
     [Fact]
-    public async Task Default_type_activator_can_initialize_a_type_if_it_has_a_parameterless_constructor()
+    public async Task I_can_configure_the_application_to_use_the_default_type_activator_to_initialize_types_through_parameterless_constructors()
     {
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        console.Output.WriteLine(""foo"");
+                    console.Output.WriteLine("foo");
-        return default;
+                    return default;
-    }
+                }
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -45,27 +48,29 @@ public class Command : ICommand
             new Dictionary<string, string>()
         );
 
-        var stdOut = FakeConsole.ReadOutputString();
-
         // Assert
         exitCode.Should().Be(0);
+
+        var stdOut = FakeConsole.ReadOutputString();
         stdOut.Trim().Should().Be("foo");
     }
 
     [Fact]
-    public async Task Default_type_activator_fails_if_the_type_does_not_have_a_parameterless_constructor()
+    public async Task I_can_configure_the_application_to_use_the_default_type_activator_and_get_an_error_if_the_requested_type_does_not_have_a_parameterless_constructor()
     {
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    public Command(string foo) {}
+                public Command(string foo) {}
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                public ValueTask ExecuteAsync(IConsole console) => default;
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -79,38 +84,40 @@ public class Command : ICommand
             new Dictionary<string, string>()
         );
 
-        var stdErr = FakeConsole.ReadErrorString();
-
         // Assert
         exitCode.Should().NotBe(0);
+
+        var stdErr = FakeConsole.ReadErrorString();
         stdErr.Should().Contain("Failed to create an instance of type");
     }
 
     [Fact]
-    public async Task Delegate_type_activator_can_initialize_a_type_using_a_custom_function()
+    public async Task I_can_configure_the_application_to_use_a_custom_type_activator_to_initialize_types_using_a_delegate()
     {
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    private readonly string _foo;
+                private readonly string _foo;
 
-    public Command(string foo) => _foo = foo;
+                public Command(string foo) => _foo = foo;
 
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        console.Output.WriteLine(_foo);
+                    console.Output.WriteLine(_foo);
-        return default;
+                    return default;
-    }
+                }
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
-            .UseTypeActivator(type => Activator.CreateInstance(type, "hello world")!)
+            .UseTypeActivator(type => Activator.CreateInstance(type, "Hello world")!)
             .Build();
 
         // Act
@@ -119,34 +126,53 @@ public class Command : ICommand
             new Dictionary<string, string>()
         );
 
-        var stdOut = FakeConsole.ReadOutputString();
-
         // Assert
         exitCode.Should().Be(0);
-        stdOut.Trim().Should().Be("hello world");
+
+        var stdOut = FakeConsole.ReadOutputString();
+        stdOut.Trim().Should().Be("Hello world");
     }
 
     [Fact]
-    public async Task Delegate_type_activator_fails_if_the_underlying_function_returns_null()
+    public async Task I_can_configure_the_application_to_use_a_custom_type_activator_to_initialize_types_using_a_service_provider()
     {
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    public ValueTask ExecuteAsync(IConsole console)
+                private readonly string _foo;
-    {
+
-        console.Output.WriteLine(""foo"");
+                public Command(string foo) => _foo = foo;
-        return default;
+
-    }
+                public ValueTask ExecuteAsync(IConsole console)
-}");
+                {
+                    console.Output.WriteLine(_foo);
+                    return default;
+                }
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
-            .UseTypeActivator(_ => null!)
+            .UseTypeActivator(commandTypes =>
+            {
+                var services = new ServiceCollection();
+
+                foreach (var serviceType in commandTypes)
+                {
+                    services.AddSingleton(
+                        serviceType,
+                        Activator.CreateInstance(serviceType, "Hello world")!
+                    );
+                }
+
+                return services.BuildServiceProvider();
+            })
             .Build();
 
         // Act
@@ -155,10 +181,48 @@ public class Command : ICommand
             new Dictionary<string, string>()
         );
 
-        var stdErr = FakeConsole.ReadErrorString();
+        // Assert
+        exitCode.Should().Be(0);
+
+        var stdOut = FakeConsole.ReadOutputString();
+        stdOut.Trim().Should().Be("Hello world");
+    }
+
+    [Fact]
+    public async Task I_can_configure_the_application_to_use_a_custom_type_activator_and_get_an_error_if_the_requested_type_cannot_be_initialized()
+    {
+        // Arrange
+        var commandType = DynamicCommandBuilder.Compile(
+            // language=cs
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("foo");
+                    return default;
+                }
+            }
+            """
+        );
+
+        var application = new CliApplicationBuilder()
+            .AddCommand(commandType)
+            .UseConsole(FakeConsole)
+            .UseTypeActivator((Type _) => null!)
+            .Build();
+
+        // Act
+        var exitCode = await application.RunAsync(
+            Array.Empty<string>(),
+            new Dictionary<string, string>()
+        );
 
         // Assert
         exitCode.Should().NotBe(0);
+
+        var stdErr = FakeConsole.ReadErrorString();
         stdErr.Should().Contain("Failed to create an instance of type");
     }
 }

CliFx.Tests/Utils/DynamicCommandBuilder.cs

@@ -11,14 +11,9 @@ using Microsoft.CodeAnalysis.Text;
 namespace CliFx.Tests.Utils;
 
 // This class uses Roslyn to compile commands dynamically.
-//
+// It allows us to collocate commands with tests more easily, which helps a lot when reasoning about them.
-// It allows us to collocate commands with tests more
+// Unfortunately, this comes at a cost of static typing, but this is still a worthwhile trade off.
-// easily, which helps a lot when reasoning about them.
+// Maybe one day C# will allow declaring classes inside methods and doing this will no longer be necessary.
-// Unfortunately, this comes at a cost of static typing,
-// but this is still a worthwhile trade off.
-//
-// Maybe one day C# will allow declaring classes inside
-// methods and doing this will no longer be necessary.
 // Language proposal: https://github.com/dotnet/csharplang/discussions/130
 internal static class DynamicCommandBuilder
 {
@@ -61,7 +56,7 @@ internal static class DynamicCommandBuilder
         var compilation = CSharpCompilation.Create(
             "CliFxTests_DynamicAssembly_" + Guid.NewGuid(),
             new[] {ast},
-            ReferenceAssemblies.Net50
+            Net70.References.All
                 .Append(MetadataReference.CreateFromFile(typeof(ICommand).Assembly.Location))
                 .Append(MetadataReference.CreateFromFile(typeof(DynamicCommandBuilder).Assembly.Location)),
             // DLL to avoid having to define the Main() method
@@ -76,9 +71,10 @@ internal static class DynamicCommandBuilder
         if (compilationErrors.Any())
         {
             throw new InvalidOperationException(
-                "Failed to compile code." +
+                $"""
-                Environment.NewLine +
+                Failed to compile code.
-                string.Join(Environment.NewLine, compilationErrors.Select(e => e.ToString()))
+                {string.Join(Environment.NewLine, compilationErrors.Select(e => e.ToString()))}
+                """
             );
         }
 
@@ -94,9 +90,10 @@ internal static class DynamicCommandBuilder
         if (emitErrors.Any())
         {
             throw new InvalidOperationException(
-                "Failed to emit code." +
+                $"""
-                Environment.NewLine +
+                Failed to emit code.
-                string.Join(Environment.NewLine, emitErrors.Select(e => e.ToString()))
+                {string.Join(Environment.NewLine, emitErrors.Select(e => e.ToString()))}
+                """
             );
         }
 
@@ -122,7 +119,6 @@ internal static class DynamicCommandBuilder
     public static Type Compile(string sourceCode)
     {
         var commandTypes = CompileMany(sourceCode);
-
         if (commandTypes.Count > 1)
         {
             throw new InvalidOperationException(

CliFx.Tests/Utils/Extensions/AssertionExtensions.cs

@@ -41,7 +41,7 @@ internal static class AssertionExtensions
             lastIndex = index;
         }
 
-        return new(assertions);
+        return new AndConstraint<StringAssertions>(assertions);
     }
 
     public static AndConstraint<StringAssertions> ContainAllInOrder(

CliFx.Tests/Utils/NoOpCommand.cs

@@ -5,7 +5,7 @@ using CliFx.Infrastructure;
 namespace CliFx.Tests.Utils;
 
 [Command]
-public class NoOpCommand : ICommand
+internal class NoOpCommand : ICommand
 {
     public ValueTask ExecuteAsync(IConsole console) => default;
 }

CliFx/ApplicationConfiguration.cs

@@ -9,22 +9,22 @@ namespace CliFx;
 public class ApplicationConfiguration
 {
     /// <summary>
-    /// Command types defined in this application.
+    /// Command types defined in the application.
     /// </summary>
     public IReadOnlyList<Type> CommandTypes { get; }
 
     /// <summary>
-    /// Whether debug mode is allowed in this application.
+    /// Whether debug mode is allowed in the application.
     /// </summary>
     public bool IsDebugModeAllowed { get; }
 
     /// <summary>
-    /// Whether preview mode is allowed in this application.
+    /// Whether preview mode is allowed in the application.
     /// </summary>
     public bool IsPreviewModeAllowed { get; }
 
     /// <summary>
-    /// Initializes an instance of <see cref="ApplicationConfiguration"/>.
+    /// Initializes an instance of <see cref="ApplicationConfiguration" />.
     /// </summary>
     public ApplicationConfiguration(
         IReadOnlyList<Type> commandTypes,

CliFx/ApplicationMetadata.cs

@@ -26,7 +26,7 @@ public class ApplicationMetadata
     public string? Description { get; }
 
     /// <summary>
-    /// Initializes an instance of <see cref="ApplicationMetadata"/>.
+    /// Initializes an instance of <see cref="ApplicationMetadata" />.
     /// </summary>
     public ApplicationMetadata(
         string title,

CliFx/Attributes/CommandAttribute.cs

@@ -9,13 +9,12 @@ namespace CliFx.Attributes;
 public sealed class CommandAttribute : Attribute
 {
     /// <summary>
-    /// Command's name.
+    /// Command name.
     /// </summary>
     /// <remarks>
-    /// Command can have no name, in which case it's treated as the default command.
+    /// Command can have no name, in which case it's treated as the application's default command.
-    ///
+    /// Only one default command is allowed in an application.
     /// All commands registered in an application must have unique names (comparison IS NOT case-sensitive).
-    /// Only one command without a name is allowed in an application.
     /// </remarks>
     public string? Name { get; }
 
@@ -26,7 +25,7 @@ public sealed class CommandAttribute : Attribute
     public string? Description { get; set; }
 
     /// <summary>
-    /// Initializes an instance of <see cref="CommandAttribute"/>.
+    /// Initializes an instance of <see cref="CommandAttribute" />.
     /// </summary>
     public CommandAttribute(string name)
     {
@@ -34,7 +33,7 @@ public sealed class CommandAttribute : Attribute
     }
 
     /// <summary>
-    /// Initializes an instance of <see cref="CommandAttribute"/>.
+    /// Initializes an instance of <see cref="CommandAttribute" />.
     /// </summary>
     public CommandAttribute()
     {

CliFx/Attributes/CommandOptionAttribute.cs

@@ -14,7 +14,7 @@ public sealed class CommandOptionAttribute : Attribute
     /// </summary>
     /// <remarks>
     /// Must contain at least two characters and start with a letter.
-    /// Either <see cref="Name"/> or <see cref="ShortName"/> must be set.
+    /// Either <see cref="Name" /> or <see cref="ShortName" /> must be set.
     /// All options in a command must have unique names (comparison IS NOT case-sensitive).
     /// </remarks>
     public string? Name { get; }
@@ -23,20 +23,24 @@ public sealed class CommandOptionAttribute : Attribute
     /// Option short name.
     /// </summary>
     /// <remarks>
-    /// Either <see cref="Name"/> or <see cref="ShortName"/> must be set.
+    /// Either <see cref="Name" /> or <see cref="ShortName" /> must be set.
     /// All options in a command must have unique short names (comparison IS case-sensitive).
     /// </remarks>
     public char? ShortName { get; }
 
     /// <summary>
-    /// Whether this option is required.
+    /// Whether this option is required (default: <c>false</c>).
     /// If an option is required, the user will get an error if they don't set it.
     /// </summary>
+    /// <remarks>
+    /// You can use the <c>required</c> keyword on the property (introduced in C# 11) to implicitly
+    /// set <see cref="IsRequired" /> to <c>true</c>.
+    /// </remarks>
     public bool IsRequired { get; set; }
 
     /// <summary>
     /// Environment variable whose value will be used as a fallback if the option
-    /// has not been explicitly set through command line arguments.
+    /// has not been explicitly set through command-line arguments.
     /// </summary>
     public string? EnvironmentVariable { get; set; }
 
@@ -47,11 +51,11 @@ public sealed class CommandOptionAttribute : Attribute
     public string? Description { get; set; }
 
     /// <summary>
-    /// Custom converter used for mapping the raw command line argument into
+    /// Custom converter used for mapping the raw command-line argument into
     /// a value expected by the underlying property.
     /// </summary>
     /// <remarks>
-    /// Converter must derive from <see cref="BindingConverter{T}"/>.
+    /// Converter must derive from <see cref="BindingConverter{T}" />.
     /// </remarks>
     public Type? Converter { get; set; }
 
@@ -60,12 +64,12 @@ public sealed class CommandOptionAttribute : Attribute
     /// property, after it has been bound.
     /// </summary>
     /// <remarks>
-    /// Validators must derive from <see cref="BindingValidator{T}"/>.
+    /// Validators must derive from <see cref="BindingValidator{T}" />.
     /// </remarks>
     public Type[] Validators { get; set; } = Array.Empty<Type>();
 
     /// <summary>
-    /// Initializes an instance of <see cref="CommandOptionAttribute"/>.
+    /// Initializes an instance of <see cref="CommandOptionAttribute" />.
     /// </summary>
     private CommandOptionAttribute(string? name, char? shortName)
     {
@@ -74,15 +78,15 @@ public sealed class CommandOptionAttribute : Attribute
     }
 
     /// <summary>
-    /// Initializes an instance of <see cref="CommandOptionAttribute"/>.
+    /// Initializes an instance of <see cref="CommandOptionAttribute" />.
     /// </summary>
     public CommandOptionAttribute(string name, char shortName)
-        : this(name, (char?) shortName)
+        : this(name, (char?)shortName)
     {
     }
 
     /// <summary>
-    /// Initializes an instance of <see cref="CommandOptionAttribute"/>.
+    /// Initializes an instance of <see cref="CommandOptionAttribute" />.
     /// </summary>
     public CommandOptionAttribute(string name)
         : this(name, null)
@@ -90,10 +94,10 @@ public sealed class CommandOptionAttribute : Attribute
     }
 
     /// <summary>
-    /// Initializes an instance of <see cref="CommandOptionAttribute"/>.
+    /// Initializes an instance of <see cref="CommandOptionAttribute" />.
     /// </summary>
     public CommandOptionAttribute(char shortName)
-        : this(null, (char?) shortName)
+        : this(null, (char?)shortName)
     {
     }
 }

CliFx/Attributes/CommandParameterAttribute.cs

@@ -11,18 +11,25 @@ public sealed class CommandParameterAttribute : Attribute
 {
     /// <summary>
     /// Parameter order.
+    /// Higher order means the parameter appears later, lower order means it appears earlier.
     /// </summary>
     /// <remarks>
-    /// Higher order means the parameter appears later, lower order means
-    /// it appears earlier.
-    ///
     /// All parameters in a command must have unique order.
-    ///
     /// Parameter whose type is a non-scalar (e.g. array), must always be the last in order.
     /// Only one non-scalar parameter is allowed in a command.
     /// </remarks>
     public int Order { get; }
 
+    /// <summary>
+    /// Whether this parameter is required (default: <c>true</c>).
+    /// If a parameter is required, the user will get an error if they don't set it.
+    /// </summary>
+    /// <remarks>
+    /// Parameter marked as non-required must always be the last in order.
+    /// Only one non-required parameter is allowed in a command.
+    /// </remarks>
+    public bool IsRequired { get; set; } = true;
+
     /// <summary>
     /// Parameter name.
     /// This is shown to the user in the help text.
@@ -39,11 +46,11 @@ public sealed class CommandParameterAttribute : Attribute
     public string? Description { get; set; }
 
     /// <summary>
-    /// Custom converter used for mapping the raw command line argument into
+    /// Custom converter used for mapping the raw command-line argument into
     /// a value expected by the underlying property.
     /// </summary>
     /// <remarks>
-    /// Converter must derive from <see cref="BindingConverter{T}"/>.
+    /// Converter must derive from <see cref="BindingConverter{T}" />.
     /// </remarks>
     public Type? Converter { get; set; }
 
@@ -52,12 +59,12 @@ public sealed class CommandParameterAttribute : Attribute
     /// property, after it has been bound.
     /// </summary>
     /// <remarks>
-    /// Validators must derive from <see cref="BindingValidator{T}"/>.
+    /// Validators must derive from <see cref="BindingValidator{T}" />.
     /// </remarks>
     public Type[] Validators { get; set; } = Array.Empty<Type>();
 
     /// <summary>
-    /// Initializes an instance of <see cref="CommandParameterAttribute"/>.
+    /// Initializes an instance of <see cref="CommandParameterAttribute" />.
     /// </summary>
     public CommandParameterAttribute(int order)
     {

CliFx/CliApplication.cs

@@ -2,6 +2,7 @@ using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
+using System.Runtime.InteropServices;
 using System.Threading.Tasks;
 using CliFx.Exceptions;
 using CliFx.Formatting;
@@ -14,7 +15,7 @@ using CliFx.Utils.Extensions;
 namespace CliFx;
 
 /// <summary>
-/// Command line application facade.
+/// Command-line application facade.
 /// </summary>
 public class CliApplication
 {
@@ -34,7 +35,7 @@ public class CliApplication
     private readonly CommandBinder _commandBinder;
 
     /// <summary>
-    /// Initializes an instance of <see cref="CliApplication"/>.
+    /// Initializes an instance of <see cref="CliApplication" />.
     /// </summary>
     public CliApplication(
         ApplicationMetadata metadata,
@@ -58,12 +59,8 @@ public class CliApplication
 
     private bool ShouldShowHelpText(CommandSchema commandSchema, CommandInput commandInput) =>
         commandSchema.IsHelpOptionAvailable && commandInput.IsHelpOptionSpecified ||
-        // Show help text also in case the fallback default command is
+        // Show help text also if the fallback default command is executed without any arguments
-        // executed without any arguments.
+        commandSchema == FallbackDefaultCommand.Schema && !commandInput.HasArguments;
-        commandSchema == FallbackDefaultCommand.Schema &&
-        string.IsNullOrWhiteSpace(commandInput.CommandName) &&
-        !commandInput.Parameters.Any() &&
-        !commandInput.Options.Any();
 
     private bool ShouldShowVersionText(CommandSchema commandSchema, CommandInput commandInput) =>
         commandSchema.IsVersionOptionAvailable && commandInput.IsVersionOptionSpecified;
@@ -75,28 +72,30 @@ public class CliApplication
             var processId = ProcessEx.GetCurrentProcessId();
 
             _console.Output.WriteLine(
-                $"Attach debugger to PID {processId} to continue."
+                $"Attach the debugger to process with ID {processId} to continue."
             );
         }
 
-        // Try to also launch debugger ourselves (only works if VS is installed)
+        // Try to also launch the debugger ourselves (only works with Visual Studio)
         Debugger.Launch();
 
         while (!Debugger.IsAttached)
-        {
             await Task.Delay(100);
-        }
     }
 
     private async ValueTask<int> RunAsync(ApplicationSchema applicationSchema, CommandInput commandInput)
     {
-        // Handle debug directive
+        // Console colors may have already been overridden by the parent process,
+        // so we need to reset it to make sure that everything we write looks properly.
+        _console.ResetColor();
+
+        // Handle the debug directive
         if (IsDebugModeEnabled(commandInput))
         {
             await PromptDebuggerAsync();
         }
 
-        // Handle preview directive
+        // Handle the preview directive
         if (IsPreviewModeEnabled(commandInput))
         {
             _console.Output.WriteCommandInput(commandInput);
@@ -105,16 +104,23 @@ public class CliApplication
 
         // Try to get the command schema that matches the input
         var commandSchema =
-            applicationSchema.TryFindCommand(commandInput.CommandName) ??
+            (!string.IsNullOrWhiteSpace(commandInput.CommandName)
-            applicationSchema.TryFindDefaultCommand() ??
+                // If the command name is specified, try to find the command by name.
+                // This should always succeed, because the input parsing relies on
+                // the list of available command names.
+                ? applicationSchema.TryFindCommand(commandInput.CommandName)
+                // Otherwise, try to find the default command
+                : applicationSchema.TryFindDefaultCommand()) ??
+            // If a valid command was not found, use the fallback default command.
+            // This is only used as a stub to show the help text.
             FallbackDefaultCommand.Schema;
 
-        // Activate command instance
+        // Initialize an instance of the command type
         var commandInstance = commandSchema == FallbackDefaultCommand.Schema
-            ? new FallbackDefaultCommand() // bypass activator
+            ? new FallbackDefaultCommand() // bypass the activator
-            : (ICommand) _typeActivator.CreateInstance(commandSchema.Type);
+            : _typeActivator.CreateInstance<ICommand>(commandSchema.Type);
 
-        // Assemble help context
+        // Assemble the help context
         var helpContext = new HelpContext(
             Metadata,
             applicationSchema,
@@ -122,14 +128,14 @@ public class CliApplication
             commandSchema.GetValues(commandInstance)
         );
 
-        // Handle help option
+        // Handle the help option
         if (ShouldShowHelpText(commandSchema, commandInput))
         {
             _console.Output.WriteHelpText(helpContext);
             return 0;
         }
 
-        // Handle version option
+        // Handle the version option
         if (ShouldShowVersionText(commandSchema, commandInput))
         {
             _console.Output.WriteLine(Metadata.Version);
@@ -137,12 +143,12 @@ public class CliApplication
         }
 
         // Starting from this point, we may produce exceptions that are meant for the
-        // end user of the application (i.e. invalid input, command exception, etc).
+        // end-user of the application (i.e. invalid input, command exception, etc).
         // Catch these exceptions here, print them to the console, and don't let them
         // propagate further.
         try
         {
-            // Bind and execute command
+            // Bind and execute the command
             _commandBinder.Bind(commandInput, commandSchema, commandInstance);
             await commandInstance.ExecuteAsync(_console);
 
@@ -163,12 +169,12 @@ public class CliApplication
     }
 
     /// <summary>
-    /// Runs the application with the specified command line arguments and environment variables.
+    /// Runs the application with the specified command-line arguments and environment variables.
-    /// Returns an exit code which indicates whether the application completed successfully.
+    /// Returns the exit code which indicates whether the application completed successfully.
     /// </summary>
     /// <remarks>
-    /// When running WITHOUT debugger (i.e. in production), this method swallows all exceptions and
+    /// When running WITHOUT the debugger attached (i.e. in production), this method swallows
-    /// reports them to the console.
+    /// all exceptions and reports them to the console.
     /// </remarks>
     public async ValueTask<int> RunAsync(
         IReadOnlyList<string> commandLineArguments,
@@ -176,10 +182,6 @@ public class CliApplication
     {
         try
         {
-            // Console colors may have already been overriden by the parent process,
-            // so we need to reset it to make sure that everything we write looks properly.
-            _console.ResetColor();
-
             var applicationSchema = ApplicationSchema.Resolve(Configuration.CommandTypes);
 
             var commandInput = CommandInput.Parse(
@@ -192,10 +194,8 @@ public class CliApplication
         }
         // To prevent the app from showing the annoying troubleshooting dialog on Windows,
         // we handle all exceptions ourselves and print them to the console.
-        //
         // We only want to do that if the app is running in production, which we infer
-        // based on whether a debugger is attached to the process.
+        // based on whether the debugger is attached to the process.
-        //
         // When not running in production, we want the IDE to show exceptions to the
         // developer, so we don't swallow them in that case.
         catch (Exception ex) when (!Debugger.IsAttached)
@@ -206,31 +206,32 @@ public class CliApplication
     }
 
     /// <summary>
-    /// Runs the application with the specified command line arguments.
+    /// Runs the application with the specified command-line arguments.
-    /// Environment variables are resolved automatically.
+    /// Returns the exit code which indicates whether the application completed successfully.
-    /// Returns an exit code which indicates whether the application completed successfully.
     /// </summary>
     /// <remarks>
-    /// When running WITHOUT debugger (i.e. in production), this method swallows all exceptions and
+    /// When running WITHOUT the debugger attached (i.e. in production), this method swallows
-    /// reports them to the console.
+    /// all exceptions and reports them to the console.
     /// </remarks>
     public async ValueTask<int> RunAsync(IReadOnlyList<string> commandLineArguments) => await RunAsync(
         commandLineArguments,
-        // Use case-sensitive comparison because environment variables are
-        // case-sensitive on Linux and macOS (but not on Windows).
         Environment
             .GetEnvironmentVariables()
-            .ToDictionary<string, string>(StringComparer.Ordinal)
+            .ToDictionary<string, string>(
+                RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
+                    ? StringComparer.OrdinalIgnoreCase
+                    : StringComparer.Ordinal
+            )
     );
 
     /// <summary>
     /// Runs the application.
-    /// Command line arguments and environment variables are resolved automatically.
+    /// Command-line arguments and environment variables are resolved automatically.
-    /// Returns an exit code which indicates whether the application completed successfully.
+    /// Returns the exit code which indicates whether the application completed successfully.
     /// </summary>
     /// <remarks>
-    /// When running WITHOUT debugger (i.e. in production), this method swallows all exceptions and
+    /// When running WITHOUT the debugger attached (i.e. in production), this method swallows
-    /// reports them to the console.
+    /// all exceptions and reports them to the console.
     /// </remarks>
     public async ValueTask<int> RunAsync() => await RunAsync(
         Environment.GetCommandLineArgs()

CliFx/CliApplicationBuilder.cs

@@ -6,12 +6,13 @@ using System.Reflection;
 using CliFx.Attributes;
 using CliFx.Infrastructure;
 using CliFx.Schema;
+using CliFx.Utils;
 using CliFx.Utils.Extensions;
 
 namespace CliFx;
 
 /// <summary>
-/// Builder for <see cref="CliApplication"/>.
+/// Builder for <see cref="CliApplication" />.
 /// </summary>
 public partial class CliApplicationBuilder
 {
@@ -21,7 +22,7 @@ public partial class CliApplicationBuilder
     private bool _isPreviewModeAllowed = true;
     private string? _title;
     private string? _executableName;
-    private string? _versionText;
+    private string? _version;
     private string? _description;
     private IConsole? _console;
     private ITypeActivator? _typeActivator;
@@ -32,7 +33,6 @@ public partial class CliApplicationBuilder
     public CliApplicationBuilder AddCommand(Type commandType)
     {
         _commandTypes.Add(commandType);
-
         return this;
     }
 
@@ -57,8 +57,8 @@ public partial class CliApplicationBuilder
     /// Adds commands from the specified assembly to the application.
     /// </summary>
     /// <remarks>
-    /// This method looks for public non-abstract classes that implement <see cref="ICommand"/>
+    /// This method looks for public non-abstract classes that implement <see cref="ICommand" />
-    /// and are annotated by <see cref="CommandAttribute"/>.
+    /// and are annotated by <see cref="CommandAttribute" />.
     /// </remarks>
     public CliApplicationBuilder AddCommandsFrom(Assembly commandAssembly)
     {
@@ -72,8 +72,8 @@ public partial class CliApplicationBuilder
     /// Adds commands from the specified assemblies to the application.
     /// </summary>
     /// <remarks>
-    /// This method looks for public non-abstract classes that implement <see cref="ICommand"/>
+    /// This method looks for public non-abstract classes that implement <see cref="ICommand" />
-    /// and are annotated by <see cref="CommandAttribute"/>.
+    /// and are annotated by <see cref="CommandAttribute" />.
     /// </remarks>
     public CliApplicationBuilder AddCommandsFrom(IEnumerable<Assembly> commandAssemblies)
     {
@@ -87,8 +87,8 @@ public partial class CliApplicationBuilder
     /// Adds commands from the calling assembly to the application.
     /// </summary>
     /// <remarks>
-    /// This method looks for public non-abstract classes that implement <see cref="ICommand"/>
+    /// This method looks for public non-abstract classes that implement <see cref="ICommand" />
-    /// and are annotated by <see cref="CommandAttribute"/>.
+    /// and are annotated by <see cref="CommandAttribute" />.
     /// </remarks>
     public CliApplicationBuilder AddCommandsFromThisAssembly() => AddCommandsFrom(Assembly.GetCallingAssembly());
 
@@ -111,7 +111,7 @@ public partial class CliApplicationBuilder
     }
 
     /// <summary>
-    /// Sets application title, which is shown in the help text.
+    /// Sets the application title, which is shown in the help text.
     /// </summary>
     /// <remarks>
     /// By default, application title is inferred from the assembly name.
@@ -123,11 +123,10 @@ public partial class CliApplicationBuilder
     }
 
     /// <summary>
-    /// Sets application executable name, which is shown in the help text.
+    /// Sets the application executable name, which is shown in the help text.
     /// </summary>
     /// <remarks>
     /// By default, application executable name is inferred from the assembly file name.
-    /// The file name is also prefixed with `dotnet` if it's a DLL file.
     /// </remarks>
     public CliApplicationBuilder SetExecutableName(string executableName)
     {
@@ -136,20 +135,19 @@ public partial class CliApplicationBuilder
     }
 
     /// <summary>
-    /// Sets application version, which is shown in the help text or
+    /// Sets the application version, which is shown in the help text or when the user specifies the version option.
-    /// when the user specifies the version option.
     /// </summary>
     /// <remarks>
     /// By default, application version is inferred from the assembly version.
     /// </remarks>
     public CliApplicationBuilder SetVersion(string version)
     {
-        _versionText = version;
+        _version = version;
         return this;
     }
 
     /// <summary>
-    /// Sets application description, which is shown in the help text.
+    /// Sets the application description, which is shown in the help text.
     /// </summary>
     public CliApplicationBuilder SetDescription(string? description)
     {
@@ -158,7 +156,7 @@ public partial class CliApplicationBuilder
     }
 
     /// <summary>
-    /// Configures the application to use the specified implementation of <see cref="IConsole"/>.
+    /// Configures the application to use the specified implementation of <see cref="IConsole" />.
     /// </summary>
     public CliApplicationBuilder UseConsole(IConsole console)
     {
@@ -167,7 +165,7 @@ public partial class CliApplicationBuilder
     }
 
     /// <summary>
-    /// Configures the application to use the specified implementation of <see cref="ITypeActivator"/>.
+    /// Configures the application to use the specified implementation of <see cref="ITypeActivator" />.
     /// </summary>
     public CliApplicationBuilder UseTypeActivator(ITypeActivator typeActivator)
     {
@@ -176,20 +174,34 @@ public partial class CliApplicationBuilder
     }
 
     /// <summary>
-    /// Configures the application to use the specified function for activating types.
+    /// Configures the application to use the specified delegate for activating types.
     /// </summary>
-    public CliApplicationBuilder UseTypeActivator(Func<Type, object> typeActivator) =>
+    public CliApplicationBuilder UseTypeActivator(Func<Type, object> createInstance) =>
-        UseTypeActivator(new DelegateTypeActivator(typeActivator));
+        UseTypeActivator(new DelegateTypeActivator(createInstance));
 
     /// <summary>
-    /// Creates a configured instance of <see cref="CliApplication"/>.
+    /// Configures the application to use the specified service provider for activating types.
+    /// </summary>
+    public CliApplicationBuilder UseTypeActivator(IServiceProvider serviceProvider) =>
+        UseTypeActivator(serviceProvider.GetService);
+
+    /// <summary>
+    /// Configures the application to use the specified service provider for activating types.
+    /// This method takes a delegate that receives the list of all added command types, so that you can
+    /// easily register them with the service provider.
+    /// </summary>
+    public CliApplicationBuilder UseTypeActivator(Func<IReadOnlyList<Type>, IServiceProvider> getServiceProvider) =>
+        UseTypeActivator(getServiceProvider(_commandTypes.ToArray()));
+
+    /// <summary>
+    /// Creates a configured instance of <see cref="CliApplication" />.
     /// </summary>
     public CliApplication Build()
     {
         var metadata = new ApplicationMetadata(
             _title ?? GetDefaultTitle(),
             _executableName ?? GetDefaultExecutableName(),
-            _versionText ?? GetDefaultVersionText(),
+            _version ?? GetDefaultVersionText(),
             _description
         );
 
@@ -210,42 +222,63 @@ public partial class CliApplicationBuilder
 
 public partial class CliApplicationBuilder
 {
-    private static readonly Lazy<Assembly?> EntryAssemblyLazy = new(Assembly.GetEntryAssembly);
-
-    // Entry assembly can be null, for example in tests
-    private static Assembly? EntryAssembly => EntryAssemblyLazy.Value;
-
     private static string GetDefaultTitle()
     {
-        var entryAssemblyName = EntryAssembly?.GetName().Name;
+        var entryAssemblyName = EnvironmentEx.EntryAssembly?.GetName().Name;
         if (string.IsNullOrWhiteSpace(entryAssemblyName))
-            return "App";
+        {
+            throw new InvalidOperationException(
+                "Failed to infer the default application title. " +
+                $"Please specify it explicitly using {nameof(SetTitle)}()."
+            );
+        }
 
         return entryAssemblyName;
     }
 
     private static string GetDefaultExecutableName()
     {
-        var entryAssemblyLocation = EntryAssembly?.Location;
+        var entryAssemblyFilePath = EnvironmentEx.EntryAssembly?.Location;
-        if (string.IsNullOrWhiteSpace(entryAssemblyLocation))
+        var processFilePath = EnvironmentEx.ProcessPath;
-            return "app";
 
-        // The assembly can be an .exe or a .dll, depending on how it was packaged
+        if (string.IsNullOrWhiteSpace(entryAssemblyFilePath) || string.IsNullOrWhiteSpace(processFilePath))
-        var isDll = string.Equals(
+        {
-            Path.GetExtension(entryAssemblyLocation),
+            throw new InvalidOperationException(
-            ".dll",
+                "Failed to infer the default application executable name. " +
-            StringComparison.OrdinalIgnoreCase
+                $"Please specify it explicitly using {nameof(SetExecutableName)}()."
-        );
+            );
+        }
 
-        var name = isDll
+        // If the process path matches the entry assembly path, it's a legacy .NET Framework app
-            ? "dotnet " + Path.GetFileName(entryAssemblyLocation)
+        // or a self-contained .NET Core app.
-            : Path.GetFileNameWithoutExtension(entryAssemblyLocation);
+        if (PathEx.AreEqual(entryAssemblyFilePath, processFilePath))
+        {
+            return Path.GetFileNameWithoutExtension(entryAssemblyFilePath);
+        }
 
-        return name;
+        // If the process path has the same name and parent directory as the entry assembly path,
+        // but different extension, it's a framework-dependent .NET Core app launched through the apphost.
+        if (PathEx.AreEqual(Path.ChangeExtension(entryAssemblyFilePath, "exe"), processFilePath) ||
+            PathEx.AreEqual(Path.GetFileNameWithoutExtension(entryAssemblyFilePath), processFilePath))
+        {
+            return Path.GetFileNameWithoutExtension(entryAssemblyFilePath);
+        }
+
+        // Otherwise, it's a framework-dependent .NET Core app launched through the .NET CLI
+        return "dotnet " + Path.GetFileName(entryAssemblyFilePath);
     }
 
-    private static string GetDefaultVersionText() =>
+    private static string GetDefaultVersionText()
-        EntryAssembly is not null
+    {
-            ? "v" + EntryAssembly.GetName().Version.ToSemanticString()
+        var entryAssemblyVersion = EnvironmentEx.EntryAssembly?.GetName().Version;
-            : "v1.0";
+        if (entryAssemblyVersion is null)
+        {
+            throw new InvalidOperationException(
+                "Failed to infer the default application version. " +
+                $"Please specify it explicitly using {nameof(SetVersion)}()."
+            );
+        }
+
+        return "v" + entryAssemblyVersion.ToSemanticString();
+    }
 }

CliFx/CliFx.csproj

@@ -1,13 +1,16 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>netstandard2.1;netstandard2.0</TargetFrameworks>
+    <TargetFrameworks>netstandard2.0;netstandard2.1</TargetFrameworks>
+    <IsPackable>true</IsPackable>
+  </PropertyGroup>
+
+  <PropertyGroup>
     <Authors>$(Company)</Authors>
-    <Description>Declarative framework for building command line applications</Description>
+    <Description>Class-first framework for building command-line interfaces</Description>
     <PackageTags>command line executable interface framework parser arguments cli app application net core</PackageTags>
     <PackageProjectUrl>https://github.com/Tyrrrz/CliFx</PackageProjectUrl>
     <PackageReleaseNotes>https://github.com/Tyrrrz/CliFx/blob/master/Changelog.md</PackageReleaseNotes>
-    <PackageReadmeFile>Readme.md</PackageReadmeFile>
     <PackageIcon>favicon.png</PackageIcon>
     <PackageLicenseExpression>MIT</PackageLicenseExpression>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
@@ -17,23 +20,28 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <None Include="../Readme.md" Pack="true" PackagePath="" Visible="false" />
     <None Include="../favicon.png" Pack="true" PackagePath="" Visible="false" />
   </ItemGroup>
 
   <ItemGroup>
     <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.1.1" PrivateAssets="all" />
-    <PackageReference Include="Nullable" Version="1.3.0" PrivateAssets="all" />
+    <PackageReference Include="PolyShim" Version="1.2.0" PrivateAssets="all" />
+    <PackageReference Include="System.Threading.Tasks.Extensions" Version="4.5.4" Condition="'$(TargetFramework)' == 'netstandard2.0'" />
   </ItemGroup>
 
-  <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
+  <!-- Embed the analyzer inside the package -->
-    <PackageReference Include="System.Threading.Tasks.Extensions" Version="4.5.4" />
-  </ItemGroup>
-
-  <!-- Pack the analyzer assembly inside the package -->
   <ItemGroup>
-    <ProjectReference Include="../CliFx.Analyzers/CliFx.Analyzers.csproj" ReferenceOutputAssembly="false" OutputItemType="Analyzer" />
+    <ProjectReference Include="../CliFx.Analyzers/CliFx.Analyzers.csproj" ReferenceOutputAssembly="false" OutputItemType="analyzer" />
+    <None Include="../CliFx.Analyzers/bin/$(Configuration)/netstandard2.0/CliFx.Analyzers.deps.json" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
     <None Include="../CliFx.Analyzers/bin/$(Configuration)/netstandard2.0/CliFx.Analyzers.dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
+    <None Include="../CliFx.Analyzers/bin/$(Configuration)/netstandard2.0/System.Buffers.dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
+    <None Include="../CliFx.Analyzers/bin/$(Configuration)/netstandard2.0/System.Collections.Immutable.dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
+    <None Include="../CliFx.Analyzers/bin/$(Configuration)/netstandard2.0/System.Memory.dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
+    <None Include="../CliFx.Analyzers/bin/$(Configuration)/netstandard2.0/System.Numerics.Vectors.dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
+    <None Include="../CliFx.Analyzers/bin/$(Configuration)/netstandard2.0/System.Reflection.Metadata.dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
+    <None Include="../CliFx.Analyzers/bin/$(Configuration)/netstandard2.0/System.Runtime.CompilerServices.Unsafe.dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
+    <None Include="../CliFx.Analyzers/bin/$(Configuration)/netstandard2.0/System.Text.Encoding.CodePages.dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
+    <None Include="../CliFx.Analyzers/bin/$(Configuration)/netstandard2.0/System.Threading.Tasks.Extensions.dll" Pack="true" PackagePath="analyzers/dotnet/cs" Visible="false" />
   </ItemGroup>
 
 </Project>

CliFx/CommandBinder.cs

@@ -27,11 +27,11 @@ internal class CommandBinder
         // Custom converter
         if (memberSchema.ConverterType is not null)
         {
-            var converter = (IBindingConverter) _typeActivator.CreateInstance(memberSchema.ConverterType);
+            var converter = _typeActivator.CreateInstance<IBindingConverter>(memberSchema.ConverterType);
             return converter.Convert(rawValue);
         }
 
-        // Assignable from string (e.g. string itself, object, etc)
+        // Assignable from a string (e.g. string itself, object, etc)
         if (targetType.IsAssignableFrom(typeof(string)))
         {
             return rawValue;
@@ -43,12 +43,6 @@ internal class CommandBinder
             return string.IsNullOrWhiteSpace(rawValue) || bool.Parse(rawValue);
         }
 
-        // IConvertible primitives (int, double, char, etc)
-        if (targetType.IsConvertible())
-        {
-            return Convert.ChangeType(rawValue, targetType, _formatProvider);
-        }
-
         // Special case for DateTimeOffset
         if (targetType == typeof(DateTimeOffset))
         {
@@ -68,6 +62,12 @@ internal class CommandBinder
             return Enum.Parse(targetType, rawValue!, true);
         }
 
+        // Convertible primitives (int, double, char, etc)
+        if (targetType.Implements(typeof(IConvertible)))
+        {
+            return Convert.ChangeType(rawValue, targetType, _formatProvider);
+        }
+
         // Nullable<T>
         var nullableUnderlyingType = targetType.TryGetNullableUnderlyingType();
         if (nullableUnderlyingType is not null)
@@ -77,33 +77,33 @@ internal class CommandBinder
                 : null;
         }
 
-        // String-constructible (FileInfo, etc)
+        // String-constructable (FileInfo, etc)
-        var stringConstructor = targetType.GetConstructor(new[] {typeof(string)});
+        var stringConstructor = targetType.GetConstructor(new[] { typeof(string) });
         if (stringConstructor is not null)
         {
-            return stringConstructor.Invoke(new object?[] {rawValue});
+            return stringConstructor.Invoke(new object?[] { rawValue });
         }
 
         // String-parseable (with IFormatProvider)
         var parseMethodWithFormatProvider = targetType.TryGetStaticParseMethod(true);
         if (parseMethodWithFormatProvider is not null)
         {
-            return parseMethodWithFormatProvider.Invoke(null, new object?[] {rawValue, _formatProvider});
+            return parseMethodWithFormatProvider.Invoke(null, new object?[] { rawValue, _formatProvider });
         }
 
         // String-parseable (without IFormatProvider)
         var parseMethod = targetType.TryGetStaticParseMethod();
         if (parseMethod is not null)
         {
-            return parseMethod.Invoke(null, new object?[] {rawValue});
+            return parseMethod.Invoke(null, new object?[] { rawValue });
         }
 
         throw CliFxException.InternalError(
-            $"{memberSchema.GetKind()} {memberSchema.GetFormattedIdentifier()} has an unsupported underlying property type." +
+            $"""
-            Environment.NewLine +
+            {memberSchema.GetKind()} {memberSchema.GetFormattedIdentifier()} has an unsupported underlying property type.
-            $"There is no known way to convert a string value into an instance of type `{targetType.FullName}`." +
+            There is no known way to convert a string value into an instance of type `{targetType.FullName}`.
-            Environment.NewLine +
+            To fix this, either change the property to use a supported type or configure a custom converter.
-            "To fix this, either change the property to use a supported type or configure a custom converter."
+            """
         );
     }
 
@@ -125,64 +125,72 @@ internal class CommandBinder
             return array;
         }
 
-        // Array-constructible (List<T>, HashSet<T>, etc)
+        // Array-constructable (List<T>, HashSet<T>, etc)
-        var arrayConstructor = targetEnumerableType.GetConstructor(new[] {arrayType});
+        var arrayConstructor = targetEnumerableType.GetConstructor(new[] { arrayType });
         if (arrayConstructor is not null)
         {
-            return arrayConstructor.Invoke(new object?[] {array});
+            return arrayConstructor.Invoke(new object?[] { array });
         }
 
         throw CliFxException.InternalError(
-            $"{memberSchema.GetKind()} {memberSchema.GetFormattedIdentifier()} has an unsupported underlying property type." +
+            $"""
-            Environment.NewLine +
+            {memberSchema.GetKind()} {memberSchema.GetFormattedIdentifier()} has an unsupported underlying property type.
-            $"There is no known way to convert an array of `{targetElementType.FullName}` into an instance of type `{targetEnumerableType.FullName}`." +
+            There is no known way to convert an array of `{targetElementType.FullName}` into an instance of type `{targetEnumerableType.FullName}`.
-            Environment.NewLine +
+            To fix this, change the property to use a type which can be assigned from an array or a type which has a constructor that accepts an array.
-            "To fix this, change the property to use a type which can be assigned from an array or a type that has a constructor which accepts an array."
+            """
         );
     }
 
     private object? ConvertMember(IMemberSchema memberSchema, IReadOnlyList<string> rawValues)
     {
-        var targetType = memberSchema.Property.Type;
-
         try
         {
             // Non-scalar
-            var enumerableUnderlyingType = targetType.TryGetEnumerableUnderlyingType();
+            var enumerableUnderlyingType = memberSchema.Property.Type.TryGetEnumerableUnderlyingType();
-            if (targetType != typeof(string) && enumerableUnderlyingType is not null)
+            if (enumerableUnderlyingType is not null && memberSchema.Property.Type != typeof(string))
             {
-                return ConvertMultiple(memberSchema, rawValues, targetType, enumerableUnderlyingType);
+                return ConvertMultiple(
+                    memberSchema,
+                    rawValues,
+                    memberSchema.Property.Type,
+                    enumerableUnderlyingType
+                );
             }
 
             // Scalar
             if (rawValues.Count <= 1)
             {
-                return ConvertSingle(memberSchema, rawValues.SingleOrDefault(), targetType);
+                return ConvertSingle(
+                    memberSchema,
+                    rawValues.SingleOrDefault(),
+                    memberSchema.Property.Type
+                );
             }
         }
         catch (Exception ex) when (ex is not CliFxException) // don't wrap CliFxException
         {
             // We use reflection-based invocation which can throw TargetInvocationException.
-            // Unwrap these exceptions to provide a more user-friendly error message.
+            // Unwrap those exceptions to provide a more user-friendly error message.
             var errorMessage = ex is TargetInvocationException invokeEx
                 ? invokeEx.InnerException?.Message ?? invokeEx.Message
                 : ex.Message;
 
             throw CliFxException.UserError(
-                $"{memberSchema.GetKind()} {memberSchema.GetFormattedIdentifier()} cannot be set from provided argument(s):" +
+                $"""
-                Environment.NewLine +
+                {memberSchema.GetKind()} {memberSchema.GetFormattedIdentifier()} cannot be set from the provided argument(s):
-                rawValues.Select(v => '<' + v + '>').JoinToString(" ") +
+                {rawValues.Select(v => '<' + v + '>').JoinToString(" ")}
-                Environment.NewLine +
+                Error: {errorMessage}
-                $"Error: {errorMessage}",
+                """,
                 ex
             );
         }
 
         // Mismatch (scalar but too many values)
         throw CliFxException.UserError(
-            $"{memberSchema.GetKind()} {memberSchema.GetFormattedIdentifier()} expects a single argument, but provided with multiple:" +
+            $"""
-            Environment.NewLine +
+            {memberSchema.GetKind()} {memberSchema.GetFormattedIdentifier()} expects a single argument, but provided with multiple:
-            rawValues.Select(v => '<' + v + '>').JoinToString(" ")
+            {rawValues.Select(v => '<' + v + '>').JoinToString(" ")}
+            """
         );
     }
 
@@ -192,7 +200,7 @@ internal class CommandBinder
 
         foreach (var validatorType in memberSchema.ValidatorTypes)
         {
-            var validator = (IBindingValidator) _typeActivator.CreateInstance(validatorType);
+            var validator = _typeActivator.CreateInstance<IBindingValidator>(validatorType);
             var error = validator.Validate(convertedValue);
 
             if (error is not null)
@@ -202,11 +210,11 @@ internal class CommandBinder
         if (errors.Any())
         {
             throw CliFxException.UserError(
-                $"{memberSchema.GetKind()} {memberSchema.GetFormattedIdentifier()} has been provided with an invalid value." +
+                $"""
-                Environment.NewLine +
+                {memberSchema.GetKind()} {memberSchema.GetFormattedIdentifier()} has been provided with an invalid value.
-                "Error(s):" +
+                Error(s):
-                Environment.NewLine +
+                {errors.Select(e => "- " + e.Message).JoinToString(Environment.NewLine)}
-                errors.Select(e => "- " + e.Message).JoinToString(Environment.NewLine)
+                """
             );
         }
     }
@@ -223,7 +231,7 @@ internal class CommandBinder
     {
         // Ensure there are no unexpected parameters and that all parameters are provided
         var remainingParameterInputs = commandInput.Parameters.ToList();
-        var remainingParameterSchemas = commandSchema.Parameters.ToList();
+        var remainingRequiredParameterSchemas = commandSchema.Parameters.Where(p => p.IsRequired).ToList();
 
         var position = 0;
 
@@ -233,19 +241,19 @@ internal class CommandBinder
             if (position >= commandInput.Parameters.Count)
                 break;
 
-            // Scalar - take one input at the current position
+            // Scalar: take one input at the current position
             if (parameterSchema.Property.IsScalar())
             {
                 var parameterInput = commandInput.Parameters[position];
 
-                var rawValues = new[] {parameterInput.Value};
+                var rawValues = new[] { parameterInput.Value };
                 BindMember(parameterSchema, commandInstance, rawValues);
 
                 position++;
 
                 remainingParameterInputs.Remove(parameterInput);
             }
-            // Non-scalar - take all remaining inputs starting from the current position
+            // Non-scalar: take all remaining inputs starting from the current position
             else
             {
                 var parameterInputs = commandInput.Parameters.Skip(position).ToArray();
@@ -258,28 +266,26 @@ internal class CommandBinder
                 remainingParameterInputs.RemoveRange(parameterInputs);
             }
 
-            remainingParameterSchemas.Remove(parameterSchema);
+            remainingRequiredParameterSchemas.Remove(parameterSchema);
         }
 
         if (remainingParameterInputs.Any())
         {
             throw CliFxException.UserError(
-                "Unexpected parameter(s):" +
+                $"""
-                Environment.NewLine +
+                Unexpected parameter(s):
-                remainingParameterInputs
+                {remainingParameterInputs.Select(p => p.GetFormattedIdentifier()).JoinToString(" ")}
-                    .Select(p => p.GetFormattedIdentifier())
+                """
-                    .JoinToString(" ")
             );
         }
 
-        if (remainingParameterSchemas.Any())
+        if (remainingRequiredParameterSchemas.Any())
         {
             throw CliFxException.UserError(
-                "Missing parameter(s):" +
+                $"""
-                Environment.NewLine +
+                Missing required parameter(s):
-                remainingParameterSchemas
+                {remainingRequiredParameterSchemas.Select(p => p.GetFormattedIdentifier()).JoinToString(" ")}
-                    .Select(o => o.GetFormattedIdentifier())
+                """
-                    .JoinToString(" ")
             );
         }
     }
@@ -308,7 +314,7 @@ internal class CommandBinder
 
                 BindMember(optionSchema, commandInstance, rawValues);
 
-                // Required options require at least one value to be set
+                // Required options need at least one value to be set
                 if (rawValues.Any())
                     remainingRequiredOptionSchemas.Remove(optionSchema);
             }
@@ -316,16 +322,16 @@ internal class CommandBinder
             else if (environmentVariableInput is not null)
             {
                 var rawValues = optionSchema.Property.IsScalar()
-                    ? new[] {environmentVariableInput.Value}
+                    ? new[] { environmentVariableInput.Value }
                     : environmentVariableInput.SplitValues();
 
                 BindMember(optionSchema, commandInstance, rawValues);
 
-                // Required options require at least one value to be set
+                // Required options need at least one value to be set
                 if (rawValues.Any())
                     remainingRequiredOptionSchemas.Remove(optionSchema);
             }
-            // No input - skip
+            // No input, skip
             else
             {
                 continue;
@@ -337,22 +343,20 @@ internal class CommandBinder
         if (remainingOptionInputs.Any())
         {
             throw CliFxException.UserError(
-                "Unrecognized option(s):" +
+                $"""
-                Environment.NewLine +
+                Unrecognized option(s):
-                remainingOptionInputs
+                {remainingOptionInputs.Select(o => o.GetFormattedIdentifier()).JoinToString(", ")}
-                    .Select(o => o.GetFormattedIdentifier())
+                """
-                    .JoinToString(", ")
             );
         }
 
         if (remainingRequiredOptionSchemas.Any())
         {
             throw CliFxException.UserError(
-                "Missing required option(s):" +
+                $"""
-                Environment.NewLine +
+                Missing required option(s):
-                remainingRequiredOptionSchemas
+                {remainingRequiredOptionSchemas.Select(o => o.GetFormattedIdentifier()).JoinToString(", ")}
-                    .Select(o => o.GetFormattedIdentifier())
+                """
-                    .JoinToString(", ")
             );
         }
     }

CliFx/Exceptions/CliFxException.cs

@@ -9,9 +9,11 @@ public partial class CliFxException : Exception
 {
     internal const int DefaultExitCode = 1;
 
-    // Regular `exception.Message` never returns null, even if
+    // When an exception is created without a message, the base Exception class
-    // it hasn't been set.
+    // provides a default message that is not very useful.
-    internal string? ActualMessage { get; }
+    // This property is used to identify whether this instance was created with
+    // a custom message, so that we can avoid printing the default message.
+    internal bool HasCustomMessage { get; }
 
     /// <summary>
     /// Returned exit code.
@@ -24,7 +26,7 @@ public partial class CliFxException : Exception
     public bool ShowHelp { get; }
 
     /// <summary>
-    /// Initializes an instance of <see cref="CliFxException"/>.
+    /// Initializes an instance of <see cref="CliFxException" />.
     /// </summary>
     public CliFxException(
         string message,
@@ -33,7 +35,7 @@ public partial class CliFxException : Exception
         Exception? innerException = null)
         : base(message, innerException)
     {
-        ActualMessage = message;
+        HasCustomMessage = !string.IsNullOrWhiteSpace(message);
         ExitCode = exitCode;
         ShowHelp = showHelp;
     }
@@ -41,13 +43,13 @@ public partial class CliFxException : Exception
 
 public partial class CliFxException
 {
-    // Internal errors don't show help because they're meant for the developer
+    // Internal errors don't show help because they're meant for the developer and
-    // and not the end-user of the application.
+    // not the end-user of the application.
     internal static CliFxException InternalError(string message, Exception? innerException = null) =>
         new(message, DefaultExitCode, false, innerException);
 
-    // User errors are typically caused by invalid input and they're meant for
+    // User errors are typically caused by invalid input and they're meant for the end-user,
-    // the end-user, so we want to show help.
+    // so we want to show help.
     internal static CliFxException UserError(string message, Exception? innerException = null) =>
         new(message, DefaultExitCode, true, innerException);
 }