Update version

Improve analyzer diagnostics
Produce analyzer errors for invalid generic arguments in converters and validators
2025-10-25 15:19:17 +00:00 · 2022-04-17 00:20:26 +00:00 · 2022-04-17 00:01:34 +00:00 · 2022-04-16 22:54:57 +00:00 · 2022-04-16 15:34:58 +00:00 · 2022-04-16 13:54:44 +00:00
159 changed files with 9617 additions and 8283 deletions
--- a/.github/FUNDING.yml
+++ b/.github/FUNDING.yml
@@ -1,3 +0,0 @@
-github: Tyrrrz
-patreon: Tyrrrz
-custom: ['buymeacoffee.com/Tyrrrz', 'tyrrrz.me/donate']
--- a/.github/ISSUE_TEMPLATE/bug-report.yml
+++ b/.github/ISSUE_TEMPLATE/bug-report.yml
@@ -0,0 +1,42 @@
+name: 🐞 Bug report
+description: Report broken functionality.
+labels: [bug]
+
+body:
+- type: markdown
+  attributes:
+    value: |
+      🧐 **Guidelines:**
+
+      - Search through [existing issues](https://github.com/Tyrrrz/CliFx/issues?q=is%3Aissue) first to ensure that this bug has not been reported before.
+      - Write a descriptive title for your issue. Avoid generic or vague titles such as "Something's not working" or "A couple of problems".
+      - Keep your issue focused on one single problem. If you have multiple bug reports, please create separate issues for each of them.
+      - Provide as much context as possible in the details section. Include screenshots, screen recordings, links, references, or anything else you may consider relevant.
+      - If you want to ask a question instead of reporting a bug, please use [discussions](https://github.com/Tyrrrz/CliFx/discussions/new) instead.
+
+- type: input
+  attributes:
+    label: Version
+    description: Which version of CliFx does this bug affect?
+    placeholder: ver X.Y.Z
+  validations:
+    required: true
+
+- type: textarea
+  attributes:
+    label: Details
+    description: Clear and thorough explanation of the bug.
+    placeholder: I was doing X expecting Y to happen, but Z happened instead.
+  validations:
+    required: true
+
+- type: textarea
+  attributes:
+    label: Steps to reproduce
+    description: Minimum steps required to reproduce the bug.
+    placeholder: |
+      - Step 1
+      - Step 2
+      - Step 3
+  validations:
+    required: true
--- a/.github/ISSUE_TEMPLATE/config.yml
+++ b/.github/ISSUE_TEMPLATE/config.yml
@@ -0,0 +1,8 @@
+blank_issues_enabled: false
+contact_links:
+  - name: 💬 Discord server
+    url: https://discord.gg/2SUWKFnHSm
+    about: Chat with the project community.
+  - name: 🗨 Discussions
+    url: https://github.com/Tyrrrz/CliFx/discussions/new
+    about: Ask and answer questions.
--- a/.github/ISSUE_TEMPLATE/feature-request.yml
+++ b/.github/ISSUE_TEMPLATE/feature-request.yml
@@ -0,0 +1,22 @@
+name: ✨ Feature request
+description: Request a new feature.
+labels: [enhancement]
+
+body:
+- type: markdown
+  attributes:
+    value: |
+      🧐 **Guidelines:**
+
+      - Search through [existing issues](https://github.com/Tyrrrz/CliFx/issues?q=is%3Aissue) first to ensure that this feature has not been requested before.
+      - Write a descriptive title for your issue. Avoid generic or vague titles such as "Some suggestions" or "Ideas for improvement".
+      - Keep your issue focused on one single problem. If you have multiple feature requests, please create separate issues for each of them.
+      - Provide as much context as possible in the details section. Include screenshots, screen recordings, links, references, or anything else you may consider relevant.
+      - If you want to ask a question instead of requesting a feature, please use [discussions](https://github.com/Tyrrrz/CliFx/discussions/new) instead.
+
+- type: textarea
+  attributes:
+    label: Details
+    description: Clear and thorough explanation of the feature you have in mind.
+  validations:
+    required: true
--- a/.github/workflows/CD.yml
+++ b/.github/workflows/CD.yml
@@ -1,27 +0,0 @@
-name: CD
-
-on:
-  push:
-    tags:
-      - "*"
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2.3.3
-
-      - name: Install .NET
-        uses: actions/setup-dotnet@v1.7.2
-        with:
-          dotnet-version: 5.0.x
-
-      - name: Pack
-        run: |
-          dotnet nuget locals all --clear
-          dotnet pack CliFx --configuration Release
-
-      - name: Deploy
-        run: dotnet nuget push CliFx/bin/Release/*.nupkg -s nuget.org -k ${{ secrets.NUGET_TOKEN }}
--- a/.github/workflows/CI.yml
+++ b/.github/workflows/CI.yml
@@ -1,30 +0,0 @@
-name: CI
-
-on: [push, pull_request]
-
-jobs:
-  build:
-    runs-on: ${{ matrix.os }}
-
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2.3.3
-
-      - name: Install .NET
-        uses: actions/setup-dotnet@v1.7.2
-        with:
-          dotnet-version: 5.0.x
-
-      - name: Build & test
-        run: |
-          dotnet nuget locals all --clear
-          dotnet test --configuration Release --logger GitHubActions
-
-      - name: Upload coverage
-        uses: codecov/codecov-action@v1.0.5
-        with:
-          token: ${{ secrets.CODECOV_TOKEN }}
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -0,0 +1,11 @@
+name: main
+
+on: [push, pull_request]
+
+jobs:
+  main:
+    uses: Tyrrrz/.github/.github/workflows/NuGet.yml@master
+    secrets:
+      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+      NUGET_TOKEN: ${{ secrets.NUGET_TOKEN }}
+      DISCORD_WEBHOOK: ${{ secrets.DISCORD_WEBHOOK }}
--- a/Changelog.md
+++ b/Changelog.md
@@ -1,3 +1,47 @@
+### v2.2.3 (17-Apr-2022)
+
+- Changed method signature of `IConsole.ReadKey()` to return `ConsoleKeyInfo` instead of `void`. The return type was originally defined as `void` by mistake. This change is source-backwards-compatible but may break on binary level if you were previously calling this method indirectly (i.e. through a library).
+- Added `FakeConsole.EnqueueKey(...)` to facilitate the testing of `IConsole.ReadKey()`. You can use this method to simulate key presses in your application.
+- Extended analyzers that verify the correctness of specified converters and validators. They now also ensure that the specified types are compatible with the type of the underlying property.
+- Improved diagnostics produced by analyzers. Where relevant, highlighted code is now limited to the property or type identifier, instead of the whole property or type declaration. Also extended the diagnostic messages with additional information.
+- Fixed an issue where throwing an exception inside a constructor of a command type resulted in an unrelated error message about the absence of a parameterless constructor.
+
+### v2.2.2 (30-Jan-2022)
+
+- Fixed an issue where `ConsoleWriter` and `ConsoleReader` were not properly thread-safe.
+- Fixed an issue where the analyzer failed to load under certain circumstances when running inside Visual Studio.
+
+### v2.2.1 (16-Jan-2022)
+
+- Fixed an issue which caused help text to not show default values for optional parameters. (Thanks [@AliReZa Sabouri](https://github.com/alirezanet))
+
+### v2.2 (11-Jan-2022)
+
+- Added support for optional parameters. A parameter can be marked as optional by setting `IsRequired = false` on the attribute. Only one parameter is allowed to be optional and such parameter must be the last in order. (Thanks [@AliReZa Sabouri](https://github.com/alirezanet))
+- Fixed an issue where parameters and options bound to properties implemented as default interface members were not working correctly. (Thanks [@AliReZa Sabouri](https://github.com/alirezanet))
+
+### v2.1 (04-Jan-2022)
+
+- Added `IConsole.Clear()` with corresponding implementations in `SystemConsole`, `FakeConsole`, and `FakeInMemoryConsole`. (Thanks [@Alex Rosenfeld](https://github.com/alexrosenfeld10))
+- Added `IConsole.ReadKey()` with corresponding implementations in `SystemConsole`, `FakeConsole`, and `FakeInMemoryConsole`. (Thanks [@Alex Rosenfeld](https://github.com/alexrosenfeld10))
+- Fixed an issue that caused parameters to appear out of order in the usage format section of the help text. (Thanks [@David Fallah](https://github.com/TAGC))
+
+### v2.0.6 (17-Jul-2021)
+
+- Fixed an issue where an exception thrown via reflection during parameter or option binding resulted in `Exception has been thrown by the target of an invocation` error instead of a more useful message. Such exceptions will now be unwrapped to provide better user experience.
+
+### v2.0.5 (09-Jul-2021)
+
+- Fixed an issue where calling `IConsole.Output.Encoding.EncodingName` and some other members threw an exception.
+- Added readme file to the package.
+
+### v2.0.4 (24-Apr-2021)
+
+- Fixed an issue where output and error streams in `SystemConsole` defaulted to UTF8 encoding with BOM when the application was running with UTF8 codepage. `ConsoleWriter` will now discard preamble from the specified encoding. This fix brings the behavior of `SystemConsole` in line with .NET's own `System.Console` which also discards preamble for output and error streams.
+- Fixed an issue where help text tried to show default values for parameters and options whose type does not override `ToString()` method.
+- Fixed an issue where help text didn't show default values for parameters and options whose type is an enumerable of nullable enums. (Thanks [@Robert Dailey](https://github.com/rcdailey))
+- Fixed an issue where specific parts of the help text weren't legible in some terminals due to low color resolution. Removed the usage of `ConsoleColor.DarkGray` in help text.
+
 ### v2.0.3 (09-Apr-2021)

 - Improved help text by showing valid values for non-scalar enum parameters and options. (Thanks [@Robert Dailey](https://github.com/rcdailey))
@@ -15,7 +59,7 @@
 ### v2.0 (21-Mar-2021)

 > Note: this major release includes many breaking changes.
-Please refer to the readme to find updated instructions and usage examples.
+> Please refer to the readme to find updated instructions and usage examples.

 - Renamed property `EnvironmentVariableName` to `EnvironmentVariable` on `CommandOption` attribute.
 - Removed most of schema validation checks that used to take place during application startup. Going forward, CliFx will be relying solely on its built-in set of Roslyn analyzers to catch common errors in command configuration.
--- a/CliFx.Analyzers.Tests/CliFx.Analyzers.Tests.csproj
+++ b/CliFx.Analyzers.Tests/CliFx.Analyzers.Tests.csproj
@@ -1,11 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
-    <TargetFramework>net5.0</TargetFramework>
-    <IsPackable>false</IsPackable>
-    <IsTestProject>true</IsTestProject>
-    <CollectCoverage>true</CollectCoverage>
-    <CoverletOutputFormat>opencover</CoverletOutputFormat>
+    <TargetFramework>net6.0</TargetFramework>
  </PropertyGroup>

  <ItemGroup>
@@ -13,13 +9,14 @@
  </ItemGroup>

  <ItemGroup>
-    <PackageReference Include="GitHubActionsTestLogger" Version="1.2.0" />
-    <PackageReference Include="FluentAssertions" Version="5.10.3" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.9.1" />
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="3.4.0" />
-    <PackageReference Include="xunit" Version="2.4.0" />
+    <PackageReference Include="Basic.Reference.Assemblies" Version="1.2.4" />
+    <PackageReference Include="GitHubActionsTestLogger" Version="1.3.0" PrivateAssets="all" />
+    <PackageReference Include="FluentAssertions" Version="6.5.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.1.0" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.1.0" />
+    <PackageReference Include="xunit" Version="2.4.1" />
    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3" PrivateAssets="all" />
-    <PackageReference Include="coverlet.msbuild" Version="3.0.3" PrivateAssets="all" />
+    <PackageReference Include="coverlet.collector" Version="3.1.2" PrivateAssets="all" />
  </ItemGroup>

  <ItemGroup>
--- a/CliFx.Analyzers.Tests/CommandMustBeAnnotatedAnalyzerSpecs.cs
+++ b/CliFx.Analyzers.Tests/CommandMustBeAnnotatedAnalyzerSpecs.cs
@@ -2,8 +2,8 @@
 using Microsoft.CodeAnalysis.Diagnostics;
 using Xunit;

-namespace CliFx.Analyzers.Tests
-{
+namespace CliFx.Analyzers.Tests;
+
 public class CommandMustBeAnnotatedAnalyzerSpecs
 {
    private static DiagnosticAnalyzer Analyzer { get; } = new CommandMustBeAnnotatedAnalyzer();
@@ -69,4 +69,3 @@ public class Foo
        Analyzer.Should().NotProduceDiagnostics(code);
    }
 }
-}
--- a/CliFx.Analyzers.Tests/CommandMustImplementInterfaceAnalyzerSpecs.cs
+++ b/CliFx.Analyzers.Tests/CommandMustImplementInterfaceAnalyzerSpecs.cs
@@ -2,8 +2,8 @@
 using Microsoft.CodeAnalysis.Diagnostics;
 using Xunit;

-namespace CliFx.Analyzers.Tests
-{
+namespace CliFx.Analyzers.Tests;
+
 public class CommandMustImplementInterfaceAnalyzerSpecs
 {
    private static DiagnosticAnalyzer Analyzer { get; } = new CommandMustImplementInterfaceAnalyzer();
@@ -55,4 +55,3 @@ public class Foo
        Analyzer.Should().NotProduceDiagnostics(code);
    }
 }
-}
--- a/CliFx.Analyzers.Tests/GeneralSpecs.cs
+++ b/CliFx.Analyzers.Tests/GeneralSpecs.cs
@@ -4,8 +4,8 @@ using FluentAssertions;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Xunit;

-namespace CliFx.Analyzers.Tests
-{
+namespace CliFx.Analyzers.Tests;
+
 public class GeneralSpecs
 {
    [Fact]
@@ -28,4 +28,3 @@ namespace CliFx.Analyzers.Tests
        diagnosticIds.Should().OnlyHaveUniqueItems();
    }
 }
-}
--- a/CliFx.Analyzers.Tests/OptionMustBeInsideCommandAnalyzerSpecs.cs
+++ b/CliFx.Analyzers.Tests/OptionMustBeInsideCommandAnalyzerSpecs.cs
@@ -2,8 +2,8 @@
 using Microsoft.CodeAnalysis.Diagnostics;
 using Xunit;

-namespace CliFx.Analyzers.Tests
-{
+namespace CliFx.Analyzers.Tests;
+
 public class OptionMustBeInsideCommandAnalyzerSpecs
 {
    private static DiagnosticAnalyzer Analyzer { get; } = new OptionMustBeInsideCommandAnalyzer();
@@ -77,4 +77,3 @@ public class MyCommand : ICommand
        Analyzer.Should().NotProduceDiagnostics(code);
    }
 }
-}
--- a/CliFx.Analyzers.Tests/OptionMustHaveNameOrShortNameAnalyzerSpecs.cs
+++ b/CliFx.Analyzers.Tests/OptionMustHaveNameOrShortNameAnalyzerSpecs.cs
@@ -2,8 +2,8 @@
 using Microsoft.CodeAnalysis.Diagnostics;
 using Xunit;

-namespace CliFx.Analyzers.Tests
-{
+namespace CliFx.Analyzers.Tests;
+
 public class OptionMustHaveNameOrShortNameAnalyzerSpecs
 {
    private static DiagnosticAnalyzer Analyzer { get; } = new OptionMustHaveNameOrShortNameAnalyzer();
@@ -83,4 +83,3 @@ public class MyCommand : ICommand
        Analyzer.Should().NotProduceDiagnostics(code);
    }
 }
-}
--- a/CliFx.Analyzers.Tests/OptionMustHaveUniqueNameAnalyzerSpecs.cs
+++ b/CliFx.Analyzers.Tests/OptionMustHaveUniqueNameAnalyzerSpecs.cs
@@ -2,8 +2,8 @@
 using Microsoft.CodeAnalysis.Diagnostics;
 using Xunit;

-namespace CliFx.Analyzers.Tests
-{
+namespace CliFx.Analyzers.Tests;
+
 public class OptionMustHaveUniqueNameAnalyzerSpecs
 {
    private static DiagnosticAnalyzer Analyzer { get; } = new OptionMustHaveUniqueNameAnalyzer();
@@ -89,4 +89,3 @@ public class MyCommand : ICommand
        Analyzer.Should().NotProduceDiagnostics(code);
    }
 }
-}
--- a/CliFx.Analyzers.Tests/OptionMustHaveUniqueShortNameAnalyzerSpecs.cs
+++ b/CliFx.Analyzers.Tests/OptionMustHaveUniqueShortNameAnalyzerSpecs.cs
@@ -2,8 +2,8 @@
 using Microsoft.CodeAnalysis.Diagnostics;
 using Xunit;

-namespace CliFx.Analyzers.Tests
-{
+namespace CliFx.Analyzers.Tests;
+
 public class OptionMustHaveUniqueShortNameAnalyzerSpecs
 {
    private static DiagnosticAnalyzer Analyzer { get; } = new OptionMustHaveUniqueShortNameAnalyzer();
@@ -111,4 +111,3 @@ public class MyCommand : ICommand
        Analyzer.Should().NotProduceDiagnostics(code);
    }
 }
-}
--- a/CliFx.Analyzers.Tests/OptionMustHaveValidConverterAnalyzerSpecs.cs
+++ b/CliFx.Analyzers.Tests/OptionMustHaveValidConverterAnalyzerSpecs.cs
@@ -2,8 +2,8 @@
 using Microsoft.CodeAnalysis.Diagnostics;
 using Xunit;

-namespace CliFx.Analyzers.Tests
-{
+namespace CliFx.Analyzers.Tests;
+
 public class OptionMustHaveValidConverterAnalyzerSpecs
 {
    private static DiagnosticAnalyzer Analyzer { get; } = new OptionMustHaveValidConverterAnalyzer();
@@ -33,7 +33,31 @@ public class MyCommand : ICommand
    }

    [Fact]
-        public void Analyzer_does_not_report_an_error_if_the_specified_option_converter_derives_from_BindingConverter()
+    public void Analyzer_reports_an_error_if_the_specified_option_converter_does_not_derive_from_a_compatible_BindingConverter()
+    {
+        // Arrange
+        // language=cs
+        const string code = @"
+public class MyConverter : BindingConverter<int>
+{
+    public override int Convert(string rawValue) => 42;
+}
+
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandOption(""foo"", Converter = typeof(MyConverter))]
+    public string Foo { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_the_specified_option_converter_derives_from_a_compatible_BindingConverter()
    {
        // Arrange
        // language=cs
@@ -93,4 +117,3 @@ public class MyCommand : ICommand
        Analyzer.Should().NotProduceDiagnostics(code);
    }
 }
-}
--- a/CliFx.Analyzers.Tests/OptionMustHaveValidNameAnalyzerSpecs.cs
+++ b/CliFx.Analyzers.Tests/OptionMustHaveValidNameAnalyzerSpecs.cs
@@ -2,8 +2,8 @@
 using Microsoft.CodeAnalysis.Diagnostics;
 using Xunit;

-namespace CliFx.Analyzers.Tests
-{
+namespace CliFx.Analyzers.Tests;
+
 public class OptionMustHaveValidNameAnalyzerSpecs
 {
    private static DiagnosticAnalyzer Analyzer { get; } = new OptionMustHaveValidNameAnalyzer();
@@ -102,4 +102,3 @@ public class MyCommand : ICommand
        Analyzer.Should().NotProduceDiagnostics(code);
    }
 }
-}
--- a/CliFx.Analyzers.Tests/OptionMustHaveValidShortNameAnalyzerSpecs.cs
+++ b/CliFx.Analyzers.Tests/OptionMustHaveValidShortNameAnalyzerSpecs.cs
@@ -2,8 +2,8 @@
 using Microsoft.CodeAnalysis.Diagnostics;
 using Xunit;

-namespace CliFx.Analyzers.Tests
-{
+namespace CliFx.Analyzers.Tests;
+
 public class OptionMustHaveValidShortNameAnalyzerSpecs
 {
    private static DiagnosticAnalyzer Analyzer { get; } = new OptionMustHaveValidShortNameAnalyzer();
@@ -83,4 +83,3 @@ public class MyCommand : ICommand
        Analyzer.Should().NotProduceDiagnostics(code);
    }
 }
-}
--- a/CliFx.Analyzers.Tests/OptionMustHaveValidValidatorsAnalyzerSpecs.cs
+++ b/CliFx.Analyzers.Tests/OptionMustHaveValidValidatorsAnalyzerSpecs.cs
@@ -2,8 +2,8 @@
 using Microsoft.CodeAnalysis.Diagnostics;
 using Xunit;

-namespace CliFx.Analyzers.Tests
-{
+namespace CliFx.Analyzers.Tests;
+
 public class OptionMustHaveValidValidatorsAnalyzerSpecs
 {
    private static DiagnosticAnalyzer Analyzer { get; } = new OptionMustHaveValidValidatorsAnalyzer();
@@ -33,7 +33,31 @@ public class MyCommand : ICommand
    }

    [Fact]
-        public void Analyzer_does_not_report_an_error_if_all_specified_option_validators_derive_from_BindingValidator()
+    public void Analyzer_reports_an_error_if_one_of_the_specified_option_validators_does_not_derive_from_a_compatible_BindingValidator()
+    {
+        // Arrange
+        // language=cs
+        const string code = @"
+public class MyValidator : BindingValidator<int>
+{
+    public override BindingValidationError Validate(int value) => Ok();
+}
+
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandOption(""foo"", Validators = new[] {typeof(MyValidator)})]
+    public string Foo { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_each_specified_option_validator_derives_from_a_compatible_BindingValidator()
    {
        // Arrange
        // language=cs
@@ -93,4 +117,3 @@ public class MyCommand : ICommand
        Analyzer.Should().NotProduceDiagnostics(code);
    }
 }
-}
--- a/CliFx.Analyzers.Tests/ParameterMustBeInsideCommandAnalyzerSpecs.cs
+++ b/CliFx.Analyzers.Tests/ParameterMustBeInsideCommandAnalyzerSpecs.cs
@@ -2,8 +2,8 @@
 using Microsoft.CodeAnalysis.Diagnostics;
 using Xunit;

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

-namespace CliFx.Analyzers.Tests
-{
+namespace CliFx.Analyzers.Tests;
+
 public class ParameterMustBeLastIfNonScalarAnalyzerSpecs
 {
    private static DiagnosticAnalyzer Analyzer { get; } = new ParameterMustBeLastIfNonScalarAnalyzer();

    [Fact]
-        public void Analyzer_reports_an_error_if_a_non_scalar_parameter_is_not_last_in_order()
+    public void Analyzer_reports_an_error_if_a_non_scalar_parameter_is_not_the_last_in_order()
    {
        // Arrange
        // language=cs
@@ -31,7 +31,7 @@ public class MyCommand : ICommand
    }

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

-namespace CliFx.Analyzers.Tests
-{
+namespace CliFx.Analyzers.Tests;
+
 public class ParameterMustBeSingleIfNonScalarAnalyzerSpecs
 {
    private static DiagnosticAnalyzer Analyzer { get; } = new ParameterMustBeSingleIfNonScalarAnalyzer();
@@ -92,4 +92,3 @@ public class MyCommand : ICommand
        Analyzer.Should().NotProduceDiagnostics(code);
    }
 }
-}
--- a/CliFx.Analyzers.Tests/ParameterMustHaveUniqueNameAnalyzerSpecs.cs
+++ b/CliFx.Analyzers.Tests/ParameterMustHaveUniqueNameAnalyzerSpecs.cs
@@ -2,8 +2,8 @@
 using Microsoft.CodeAnalysis.Diagnostics;
 using Xunit;

-namespace CliFx.Analyzers.Tests
-{
+namespace CliFx.Analyzers.Tests;
+
 public class ParameterMustHaveUniqueNameAnalyzerSpecs
 {
    private static DiagnosticAnalyzer Analyzer { get; } = new ParameterMustHaveUniqueNameAnalyzer();
@@ -70,4 +70,3 @@ public class MyCommand : ICommand
        Analyzer.Should().NotProduceDiagnostics(code);
    }
 }
-}
--- a/CliFx.Analyzers.Tests/ParameterMustHaveUniqueOrderAnalyzerSpecs.cs
+++ b/CliFx.Analyzers.Tests/ParameterMustHaveUniqueOrderAnalyzerSpecs.cs
@@ -2,8 +2,8 @@
 using Microsoft.CodeAnalysis.Diagnostics;
 using Xunit;

-namespace CliFx.Analyzers.Tests
-{
+namespace CliFx.Analyzers.Tests;
+
 public class ParameterMustHaveUniqueOrderAnalyzerSpecs
 {
    private static DiagnosticAnalyzer Analyzer { get; } = new ParameterMustHaveUniqueOrderAnalyzer();
@@ -70,4 +70,3 @@ public class MyCommand : ICommand
        Analyzer.Should().NotProduceDiagnostics(code);
    }
 }
-}
--- a/CliFx.Analyzers.Tests/ParameterMustHaveValidConverterAnalyzerSpecs.cs
+++ b/CliFx.Analyzers.Tests/ParameterMustHaveValidConverterAnalyzerSpecs.cs
@@ -2,8 +2,8 @@
 using Microsoft.CodeAnalysis.Diagnostics;
 using Xunit;

-namespace CliFx.Analyzers.Tests
-{
+namespace CliFx.Analyzers.Tests;
+
 public class ParameterMustHaveValidConverterAnalyzerSpecs
 {
    private static DiagnosticAnalyzer Analyzer { get; } = new ParameterMustHaveValidConverterAnalyzer();
@@ -33,7 +33,32 @@ public class MyCommand : ICommand
    }

    [Fact]
-        public void Analyzer_does_not_report_an_error_if_the_specified_parameter_converter_derives_from_BindingConverter()
+    public void Analyzer_reports_an_error_if_the_specified_parameter_converter_does_not_derive_from_a_compatible_BindingConverter()
+    {
+        // Arrange
+        // language=cs
+        const string code = @"
+public class MyConverter : BindingConverter<int>
+{
+    public override int Convert(string rawValue) => 42;
+}
+
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandParameter(0, Converter = typeof(MyConverter))]
+    public string Foo { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_the_specified_parameter_converter_derives_from_a_compatible_BindingConverter()
    {
        // Arrange
        // language=cs
@@ -93,4 +118,3 @@ public class MyCommand : ICommand
        Analyzer.Should().NotProduceDiagnostics(code);
    }
 }
-}
--- a/CliFx.Analyzers.Tests/ParameterMustHaveValidValidatorsAnalyzerSpecs.cs
+++ b/CliFx.Analyzers.Tests/ParameterMustHaveValidValidatorsAnalyzerSpecs.cs
@@ -2,8 +2,8 @@
 using Microsoft.CodeAnalysis.Diagnostics;
 using Xunit;

-namespace CliFx.Analyzers.Tests
-{
+namespace CliFx.Analyzers.Tests;
+
 public class ParameterMustHaveValidValidatorsAnalyzerSpecs
 {
    private static DiagnosticAnalyzer Analyzer { get; } = new ParameterMustHaveValidValidatorsAnalyzer();
@@ -33,7 +33,31 @@ public class MyCommand : ICommand
    }

    [Fact]
-        public void Analyzer_does_not_report_an_error_if_all_specified_parameter_validators_derive_from_BindingValidator()
+    public void Analyzer_reports_an_error_if_one_of_the_specified_parameter_validators_does_not_derive_from_a_compatible_BindingValidator()
+    {
+        // Arrange
+        // language=cs
+        const string code = @"
+public class MyValidator : BindingValidator<int>
+{
+    public override BindingValidationError Validate(int value) => Ok();
+}
+
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandParameter(0, Validators = new[] {typeof(MyValidator)})]
+    public string Foo { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_each_specified_parameter_validator_derives_from_a_compatible_BindingValidator()
    {
        // Arrange
        // language=cs
@@ -93,4 +117,3 @@ public class MyCommand : ICommand
        Analyzer.Should().NotProduceDiagnostics(code);
    }
 }
-}
--- a/CliFx.Analyzers.Tests/SystemConsoleShouldBeAvoidedAnalyzerSpecs.cs
+++ b/CliFx.Analyzers.Tests/SystemConsoleShouldBeAvoidedAnalyzerSpecs.cs
@@ -2,8 +2,8 @@
 using Microsoft.CodeAnalysis.Diagnostics;
 using Xunit;

-namespace CliFx.Analyzers.Tests
-{
+namespace CliFx.Analyzers.Tests;
+
 public class SystemConsoleShouldBeAvoidedAnalyzerSpecs
 {
    private static DiagnosticAnalyzer Analyzer { get; } = new SystemConsoleShouldBeAvoidedAnalyzer();
@@ -124,4 +124,3 @@ public class MyCommand : ICommand
        Analyzer.Should().NotProduceDiagnostics(code);
    }
 }
-}
--- a/CliFx.Analyzers.Tests/Utils/AnalyzerAssertions.cs
+++ b/CliFx.Analyzers.Tests/Utils/AnalyzerAssertions.cs
@@ -2,8 +2,8 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Linq;
-using System.Reflection;
 using System.Text;
+using Basic.Reference.Assemblies;
 using FluentAssertions.Execution;
 using FluentAssertions.Primitives;
 using Microsoft.CodeAnalysis;
@@ -11,8 +11,8 @@ using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Text;

-namespace CliFx.Analyzers.Tests.Utils
-{
+namespace CliFx.Analyzers.Tests.Utils;
+
 internal class AnalyzerAssertions : ReferenceTypeAssertions<DiagnosticAnalyzer, AnalyzerAssertions>
 {
    protected override string Identifier { get; } = "analyzer";
@@ -58,14 +58,8 @@ namespace CliFx.Analyzers.Tests.Utils
        var compilation = CSharpCompilation.Create(
            "CliFxTests_DynamicAssembly_" + Guid.NewGuid(),
            new[] { ast },
-                new[]
-                {
-                    MetadataReference.CreateFromFile(Assembly.Load("netstandard").Location),
-                    MetadataReference.CreateFromFile(Assembly.Load("System.Runtime").Location),
-                    MetadataReference.CreateFromFile(typeof(object).Assembly.Location),
-                    MetadataReference.CreateFromFile(typeof(Console).Assembly.Location),
-                    MetadataReference.CreateFromFile(typeof(ICommand).Assembly.Location)
-                },
+            ReferenceAssemblies.Net50
+                .Append(MetadataReference.CreateFromFile(typeof(ICommand).Assembly.Location)),
            // DLL to avoid having to define the Main() method
            new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)
        );
@@ -107,11 +101,11 @@ namespace CliFx.Analyzers.Tests.Utils
        var expectedDiagnosticIds = expectedDiagnostics.Select(d => d.Id).Distinct().ToArray();
        var producedDiagnosticIds = producedDiagnostics.Select(d => d.Id).Distinct().ToArray();

-            var result =
+        var isSuccessfulAssertion =
            expectedDiagnosticIds.Intersect(producedDiagnosticIds).Count() ==
            expectedDiagnosticIds.Length;

-            Execute.Assertion.ForCondition(result).FailWith(() =>
+        Execute.Assertion.ForCondition(isSuccessfulAssertion).FailWith(() =>
        {
            var buffer = new StringBuilder();

@@ -131,11 +125,18 @@ namespace CliFx.Analyzers.Tests.Utils

            buffer.AppendLine("Produced diagnostics:");

+            if (producedDiagnostics.Any())
+            {
                foreach (var producedDiagnostic in producedDiagnostics)
                {
                    buffer.Append("  - ");
                    buffer.Append(producedDiagnostic);
                }
+            }
+            else
+            {
+                buffer.AppendLine("  < none >");
+            }

            return new FailReason(buffer.ToString());
        });
@@ -144,10 +145,9 @@ namespace CliFx.Analyzers.Tests.Utils
    public void NotProduceDiagnostics(string sourceCode)
    {
        var producedDiagnostics = GetProducedDiagnostics(sourceCode);
+        var isSuccessfulAssertion = !producedDiagnostics.Any();

-            var result = !producedDiagnostics.Any();
-
-            Execute.Assertion.ForCondition(result).FailWith(() =>
+        Execute.Assertion.ForCondition(isSuccessfulAssertion).FailWith(() =>
        {
            var buffer = new StringBuilder();

@@ -171,4 +171,3 @@ namespace CliFx.Analyzers.Tests.Utils
 {
    public static AnalyzerAssertions Should(this DiagnosticAnalyzer analyzer) => new(analyzer);
 }
-}
--- a/CliFx.Analyzers/AnalyzerBase.cs
+++ b/CliFx.Analyzers/AnalyzerBase.cs
@@ -3,8 +3,8 @@ using CliFx.Analyzers.Utils.Extensions;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Diagnostics;

-namespace CliFx.Analyzers
-{
+namespace CliFx.Analyzers;
+
 public abstract class AnalyzerBase : DiagnosticAnalyzer
 {
    public DiagnosticDescriptor SupportedDiagnostic { get; }
@@ -28,8 +28,8 @@ namespace CliFx.Analyzers
        SupportedDiagnostics = ImmutableArray.Create(SupportedDiagnostic);
    }

-        protected Diagnostic CreateDiagnostic(Location location) =>
-            Diagnostic.Create(SupportedDiagnostic, location);
+    protected Diagnostic CreateDiagnostic(Location location, params object?[]? messageArgs) =>
+        Diagnostic.Create(SupportedDiagnostic, location, messageArgs);

    public override void Initialize(AnalysisContext context)
    {
@@ -37,4 +37,3 @@ namespace CliFx.Analyzers
        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
    }
 }
-}
--- a/CliFx.Analyzers/CliFx.Analyzers.csproj
+++ b/CliFx.Analyzers/CliFx.Analyzers.csproj
@@ -2,12 +2,13 @@

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

  <ItemGroup>
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="3.4.0" PrivateAssets="all" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.1.0" PrivateAssets="all" />
  </ItemGroup>

 </Project>
--- a/CliFx.Analyzers/CommandMustBeAnnotatedAnalyzer.cs
+++ b/CliFx.Analyzers/CommandMustBeAnnotatedAnalyzer.cs
@@ -5,8 +5,8 @@ using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;

-namespace CliFx.Analyzers
-{
+namespace CliFx.Analyzers;
+
 [DiagnosticAnalyzer(LanguageNames.CSharp)]
 public class CommandMustBeAnnotatedAnalyzer : AnalyzerBase
 {
@@ -30,18 +30,20 @@ namespace CliFx.Analyzers

        var implementsCommandInterface = type
            .AllInterfaces
-                .Any(s => s.DisplayNameMatches(SymbolNames.CliFxCommandInterface));
+            .Any(i => i.DisplayNameMatches(SymbolNames.CliFxCommandInterface));

        var hasCommandAttribute = type
            .GetAttributes()
            .Select(a => a.AttributeClass)
-                .Any(s => s.DisplayNameMatches(SymbolNames.CliFxCommandAttribute));
+            .Any(c => c.DisplayNameMatches(SymbolNames.CliFxCommandAttribute));

        // If the interface is implemented, but the attribute is missing,
        // then it's very likely a user error.
        if (implementsCommandInterface && !hasCommandAttribute)
        {
-                context.ReportDiagnostic(CreateDiagnostic(classDeclaration.GetLocation()));
+            context.ReportDiagnostic(
+                CreateDiagnostic(classDeclaration.Identifier.GetLocation())
+            );
        }
    }

@@ -51,4 +53,3 @@ namespace CliFx.Analyzers
        context.HandleClassDeclaration(Analyze);
    }
 }
-}
--- a/CliFx.Analyzers/CommandMustImplementInterfaceAnalyzer.cs
+++ b/CliFx.Analyzers/CommandMustImplementInterfaceAnalyzer.cs
@@ -5,8 +5,8 @@ using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;

-namespace CliFx.Analyzers
-{
+namespace CliFx.Analyzers;
+
 [DiagnosticAnalyzer(LanguageNames.CSharp)]
 public class CommandMustImplementInterfaceAnalyzer : AnalyzerBase
 {
@@ -25,17 +25,19 @@ namespace CliFx.Analyzers
        var hasCommandAttribute = type
            .GetAttributes()
            .Select(a => a.AttributeClass)
-                .Any(s => s.DisplayNameMatches(SymbolNames.CliFxCommandAttribute));
+            .Any(c => c.DisplayNameMatches(SymbolNames.CliFxCommandAttribute));

        var implementsCommandInterface = type
            .AllInterfaces
-                .Any(s => s.DisplayNameMatches(SymbolNames.CliFxCommandInterface));
+            .Any(i => i.DisplayNameMatches(SymbolNames.CliFxCommandInterface));

        // If the attribute is present, but the interface is not implemented,
        // it's very likely a user error.
        if (hasCommandAttribute && !implementsCommandInterface)
        {
-                context.ReportDiagnostic(CreateDiagnostic(classDeclaration.GetLocation()));
+            context.ReportDiagnostic(
+                CreateDiagnostic(classDeclaration.Identifier.GetLocation())
+            );
        }
    }

@@ -45,4 +47,3 @@ namespace CliFx.Analyzers
        context.HandleClassDeclaration(Analyze);
    }
 }
-}
--- a/CliFx.Analyzers/ObjectModel/CommandOptionSymbol.cs
+++ b/CliFx.Analyzers/ObjectModel/CommandOptionSymbol.cs
@@ -1,10 +1,10 @@
 using System.Collections.Generic;
-using Microsoft.CodeAnalysis;
 using System.Linq;
 using CliFx.Analyzers.Utils.Extensions;
+using Microsoft.CodeAnalysis;
+
+namespace CliFx.Analyzers.ObjectModel;

-namespace CliFx.Analyzers.ObjectModel
-{
 internal partial class CommandOptionSymbol
 {
    public string? Name { get; }
@@ -71,13 +71,11 @@ namespace CliFx.Analyzers.ObjectModel
    {
        var attribute = TryGetOptionAttribute(property);

-            if (attribute is null)
-                return null;
-
-            return FromAttribute(attribute);
+        return attribute is not null
+            ? FromAttribute(attribute)
+            : null;
    }

    public static bool IsOptionProperty(IPropertySymbol property) =>
        TryGetOptionAttribute(property) is not null;
 }
-}
--- a/CliFx.Analyzers/ObjectModel/CommandParameterSymbol.cs
+++ b/CliFx.Analyzers/ObjectModel/CommandParameterSymbol.cs
@@ -3,14 +3,16 @@ using System.Linq;
 using CliFx.Analyzers.Utils.Extensions;
 using Microsoft.CodeAnalysis;

-namespace CliFx.Analyzers.ObjectModel
-{
+namespace CliFx.Analyzers.ObjectModel;
+
 internal partial class CommandParameterSymbol
 {
    public int Order { get; }

    public string? Name { get; }

+    public bool? IsRequired { get; }
+
    public ITypeSymbol? ConverterType { get; }

    public IReadOnlyList<ITypeSymbol> ValidatorTypes { get; }
@@ -18,11 +20,13 @@ namespace CliFx.Analyzers.ObjectModel
    public CommandParameterSymbol(
        int order,
        string? name,
+        bool? isRequired,
        ITypeSymbol? converterType,
        IReadOnlyList<ITypeSymbol> validatorTypes)
    {
        Order = order;
        Name = name;
+        IsRequired = isRequired;
        ConverterType = converterType;
        ValidatorTypes = validatorTypes;
    }
@@ -48,6 +52,12 @@ namespace CliFx.Analyzers.ObjectModel
            .Select(a => a.Value.Value)
            .FirstOrDefault() as string;

+        var isRequired = attribute
+            .NamedArguments
+            .Where(a => a.Key == "IsRequired")
+            .Select(a => a.Value.Value)
+            .FirstOrDefault() as bool?;
+
        var converter = attribute
            .NamedArguments
            .Where(a => a.Key == "Converter")
@@ -63,20 +73,18 @@ namespace CliFx.Analyzers.ObjectModel
            .Cast<ITypeSymbol>()
            .ToArray();

-            return new CommandParameterSymbol(order, name, converter, validators);
+        return new CommandParameterSymbol(order, name, isRequired, converter, validators);
    }

    public static CommandParameterSymbol? TryResolve(IPropertySymbol property)
    {
        var attribute = TryGetParameterAttribute(property);

-            if (attribute is null)
-                return null;
-
-            return FromAttribute(attribute);
+        return attribute is not null
+            ? FromAttribute(attribute)
+            : null;
    }

    public static bool IsParameterProperty(IPropertySymbol property) =>
        TryGetParameterAttribute(property) is not null;
 }
-}
--- a/CliFx.Analyzers/ObjectModel/SymbolNames.cs
+++ b/CliFx.Analyzers/ObjectModel/SymbolNames.cs
@@ -1,5 +1,5 @@
-namespace CliFx.Analyzers.ObjectModel
-{
+namespace CliFx.Analyzers.ObjectModel;
+
 internal static class SymbolNames
 {
    public const string CliFxCommandInterface = "CliFx.ICommand";
@@ -7,9 +7,6 @@
    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>";
 }
-}
--- a/CliFx.Analyzers/OptionMustBeInsideCommandAnalyzer.cs
+++ b/CliFx.Analyzers/OptionMustBeInsideCommandAnalyzer.cs
@@ -5,8 +5,8 @@ using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;

-namespace CliFx.Analyzers
-{
+namespace CliFx.Analyzers;
+
 [DiagnosticAnalyzer(LanguageNames.CSharp)]
 public class OptionMustBeInsideCommandAnalyzer : AnalyzerBase
 {
@@ -34,11 +34,13 @@ namespace CliFx.Analyzers
        var isInsideCommand = property
            .ContainingType
            .AllInterfaces
-                .Any(s => s.DisplayNameMatches(SymbolNames.CliFxCommandInterface));
+            .Any(i => i.DisplayNameMatches(SymbolNames.CliFxCommandInterface));

        if (!isInsideCommand)
        {
-                context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+            context.ReportDiagnostic(
+                CreateDiagnostic(propertyDeclaration.Identifier.GetLocation())
+            );
        }
    }

@@ -48,4 +50,3 @@ namespace CliFx.Analyzers
        context.HandlePropertyDeclaration(Analyze);
    }
 }
-}
--- a/CliFx.Analyzers/OptionMustHaveNameOrShortNameAnalyzer.cs
+++ b/CliFx.Analyzers/OptionMustHaveNameOrShortNameAnalyzer.cs
@@ -4,8 +4,8 @@ using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;

-namespace CliFx.Analyzers
-{
+namespace CliFx.Analyzers;
+
 [DiagnosticAnalyzer(LanguageNames.CSharp)]
 public class OptionMustHaveNameOrShortNameAnalyzer : AnalyzerBase
 {
@@ -27,7 +27,9 @@ namespace CliFx.Analyzers

        if (string.IsNullOrWhiteSpace(option.Name) && option.ShortName is null)
        {
-                context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+            context.ReportDiagnostic(
+                CreateDiagnostic(propertyDeclaration.Identifier.GetLocation())
+            );
        }
    }

@@ -37,4 +39,3 @@ namespace CliFx.Analyzers
        context.HandlePropertyDeclaration(Analyze);
    }
 }
-}
--- a/CliFx.Analyzers/OptionMustHaveUniqueNameAnalyzer.cs
+++ b/CliFx.Analyzers/OptionMustHaveUniqueNameAnalyzer.cs
@@ -6,15 +6,16 @@ using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;

-namespace CliFx.Analyzers
-{
+namespace CliFx.Analyzers;
+
 [DiagnosticAnalyzer(LanguageNames.CSharp)]
 public class OptionMustHaveUniqueNameAnalyzer : AnalyzerBase
 {
    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}'.")
    {
    }

@@ -51,7 +52,12 @@ namespace CliFx.Analyzers

            if (string.Equals(option.Name, otherOption.Name, StringComparison.OrdinalIgnoreCase))
            {
-                    context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+                context.ReportDiagnostic(
+                    CreateDiagnostic(
+                        propertyDeclaration.Identifier.GetLocation(),
+                        option.Name
+                    )
+                );
            }
        }
    }
@@ -62,4 +68,3 @@ namespace CliFx.Analyzers
        context.HandlePropertyDeclaration(Analyze);
    }
 }
-}
--- a/CliFx.Analyzers/OptionMustHaveUniqueShortNameAnalyzer.cs
+++ b/CliFx.Analyzers/OptionMustHaveUniqueShortNameAnalyzer.cs
@@ -5,15 +5,16 @@ using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;

-namespace CliFx.Analyzers
-{
+namespace CliFx.Analyzers;
+
 [DiagnosticAnalyzer(LanguageNames.CSharp)]
 public class OptionMustHaveUniqueShortNameAnalyzer : AnalyzerBase
 {
    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}'.")
    {
    }

@@ -50,7 +51,12 @@ namespace CliFx.Analyzers

            if (option.ShortName == otherOption.ShortName)
            {
-                    context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+                context.ReportDiagnostic(
+                    CreateDiagnostic(
+                        propertyDeclaration.Identifier.GetLocation(),
+                        option.ShortName
+                    )
+                );
            }
        }
    }
@@ -61,4 +67,3 @@ namespace CliFx.Analyzers
        context.HandlePropertyDeclaration(Analyze);
    }
 }
-}
--- a/CliFx.Analyzers/OptionMustHaveValidConverterAnalyzer.cs
+++ b/CliFx.Analyzers/OptionMustHaveValidConverterAnalyzer.cs
@@ -5,15 +5,15 @@ using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;

-namespace CliFx.Analyzers
-{
+namespace CliFx.Analyzers;
+
 [DiagnosticAnalyzer(LanguageNames.CSharp)]
 public class OptionMustHaveValidConverterAnalyzer : AnalyzerBase
 {
    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,19 @@ namespace CliFx.Analyzers
        if (option.ConverterType is null)
            return;

-            // We check against an internal interface because checking against a generic class is a pain
-            var converterImplementsInterface = option
+        var converterValueType = option
            .ConverterType
-                .AllInterfaces
-                .Any(s => s.DisplayNameMatches(SymbolNames.CliFxBindingConverterInterface));
+            .GetBaseTypes()
+            .FirstOrDefault(t => t.ConstructedFrom.DisplayNameMatches(SymbolNames.CliFxBindingConverterClass))?
+            .TypeArguments
+            .FirstOrDefault();

-            if (!converterImplementsInterface)
+        // Value returned by the converter must be assignable to the property type
+        if (converterValueType is null || !property.Type.IsAssignableFrom(converterValueType))
        {
-                context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+            context.ReportDiagnostic(
+                CreateDiagnostic(propertyDeclaration.Identifier.GetLocation())
+            );
        }
    }

@@ -47,4 +51,3 @@ namespace CliFx.Analyzers
        context.HandlePropertyDeclaration(Analyze);
    }
 }
-}
--- a/CliFx.Analyzers/OptionMustHaveValidNameAnalyzer.cs
+++ b/CliFx.Analyzers/OptionMustHaveValidNameAnalyzer.cs
@@ -4,15 +4,16 @@ using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;

-namespace CliFx.Analyzers
-{
+namespace CliFx.Analyzers;
+
 [DiagnosticAnalyzer(LanguageNames.CSharp)]
 public class OptionMustHaveValidNameAnalyzer : AnalyzerBase
 {
    public OptionMustHaveValidNameAnalyzer()
        : base(
            "Options must have valid names",
-                "This option's name must be at least 2 characters long and must start with a letter.")
+            "This option's name must be at least 2 characters long and must start with a letter. " +
+            "Specified name: '{0}'.")
    {
    }

@@ -30,7 +31,12 @@ namespace CliFx.Analyzers

        if (option.Name.Length < 2 || !char.IsLetter(option.Name[0]))
        {
-                context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+            context.ReportDiagnostic(
+                CreateDiagnostic(
+                    propertyDeclaration.Identifier.GetLocation(),
+                    option.Name
+                )
+            );
        }
    }

@@ -40,4 +46,3 @@ namespace CliFx.Analyzers
        context.HandlePropertyDeclaration(Analyze);
    }
 }
-}
--- a/CliFx.Analyzers/OptionMustHaveValidShortNameAnalyzer.cs
+++ b/CliFx.Analyzers/OptionMustHaveValidShortNameAnalyzer.cs
@@ -4,15 +4,16 @@ using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;

-namespace CliFx.Analyzers
-{
+namespace CliFx.Analyzers;
+
 [DiagnosticAnalyzer(LanguageNames.CSharp)]
 public class OptionMustHaveValidShortNameAnalyzer : AnalyzerBase
 {
    public OptionMustHaveValidShortNameAnalyzer()
        : base(
            "Option short names must be letter characters",
-                "This option's short name must be a single letter character.")
+            "This option's short name must be a single letter character. " +
+            "Specified short name: '{0}'.")
    {
    }

@@ -30,7 +31,12 @@ namespace CliFx.Analyzers

        if (!char.IsLetter(option.ShortName.Value))
        {
-                context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+            context.ReportDiagnostic(
+                CreateDiagnostic(
+                    propertyDeclaration.Identifier.GetLocation(),
+                    option.ShortName
+                )
+            );
        }
    }

@@ -40,4 +46,3 @@ namespace CliFx.Analyzers
        context.HandlePropertyDeclaration(Analyze);
    }
 }
-}
--- a/CliFx.Analyzers/OptionMustHaveValidValidatorsAnalyzer.cs
+++ b/CliFx.Analyzers/OptionMustHaveValidValidatorsAnalyzer.cs
@@ -5,15 +5,15 @@ using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;

-namespace CliFx.Analyzers
-{
+namespace CliFx.Analyzers;
+
 [DiagnosticAnalyzer(LanguageNames.CSharp)]
 public class OptionMustHaveValidValidatorsAnalyzer : AnalyzerBase
 {
    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,18 @@ namespace CliFx.Analyzers

        foreach (var validatorType in option.ValidatorTypes)
        {
-                // We check against an internal interface because checking against a generic class is a pain
-                var validatorImplementsInterface = validatorType
-                    .AllInterfaces
-                    .Any(s => s.DisplayNameMatches(SymbolNames.CliFxBindingValidatorInterface));
+            var validatorValueType = validatorType
+                .GetBaseTypes()
+                .FirstOrDefault(t => t.ConstructedFrom.DisplayNameMatches(SymbolNames.CliFxBindingValidatorClass))?
+                .TypeArguments
+                .FirstOrDefault();

-                if (!validatorImplementsInterface)
+            // Value passed to the validator must be assignable from the property type
+            if (validatorValueType is null || !validatorValueType.IsAssignableFrom(property.Type))
            {
-                    context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+                context.ReportDiagnostic(
+                    CreateDiagnostic(propertyDeclaration.Identifier.GetLocation())
+                );

                // No need to report multiple identical diagnostics on the same node
                break;
@@ -49,4 +53,3 @@ namespace CliFx.Analyzers
        context.HandlePropertyDeclaration(Analyze);
    }
 }
-}
--- a/CliFx.Analyzers/ParameterMustBeInsideCommandAnalyzer.cs
+++ b/CliFx.Analyzers/ParameterMustBeInsideCommandAnalyzer.cs
@@ -5,8 +5,8 @@ using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;

-namespace CliFx.Analyzers
-{
+namespace CliFx.Analyzers;
+
 [DiagnosticAnalyzer(LanguageNames.CSharp)]
 public class ParameterMustBeInsideCommandAnalyzer : AnalyzerBase
 {
@@ -34,11 +34,13 @@ namespace CliFx.Analyzers
        var isInsideCommand = property
            .ContainingType
            .AllInterfaces
-                .Any(s => s.DisplayNameMatches(SymbolNames.CliFxCommandInterface));
+            .Any(i => i.DisplayNameMatches(SymbolNames.CliFxCommandInterface));

        if (!isInsideCommand)
        {
-                context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+            context.ReportDiagnostic(
+                CreateDiagnostic(propertyDeclaration.Identifier.GetLocation())
+            );
        }
    }

@@ -48,4 +50,3 @@ namespace CliFx.Analyzers
        context.HandlePropertyDeclaration(Analyze);
    }
 }
-}
--- a/CliFx.Analyzers/ParameterMustBeLastIfNonRequiredAnalyzer.cs
+++ b/CliFx.Analyzers/ParameterMustBeLastIfNonRequiredAnalyzer.cs
@@ -0,0 +1,62 @@
+using System.Linq;
+using CliFx.Analyzers.ObjectModel;
+using CliFx.Analyzers.Utils.Extensions;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace CliFx.Analyzers;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public class 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).")
+    {
+    }
+
+    private void Analyze(
+        SyntaxNodeAnalysisContext context,
+        PropertyDeclarationSyntax propertyDeclaration,
+        IPropertySymbol property)
+    {
+        if (property.ContainingType is null)
+            return;
+
+        var parameter = CommandParameterSymbol.TryResolve(property);
+        if (parameter is null)
+            return;
+
+        if (parameter.IsRequired != false)
+            return;
+
+        var otherProperties = property
+            .ContainingType
+            .GetMembers()
+            .OfType<IPropertySymbol>()
+            .Where(m => !m.Equals(property, SymbolEqualityComparer.Default))
+            .ToArray();
+
+        foreach (var otherProperty in otherProperties)
+        {
+            var otherParameter = CommandParameterSymbol.TryResolve(otherProperty);
+            if (otherParameter is null)
+                continue;
+
+            if (otherParameter.Order > parameter.Order)
+            {
+                context.ReportDiagnostic(
+                    CreateDiagnostic(propertyDeclaration.Identifier.GetLocation())
+                );
+            }
+        }
+    }
+
+    public override void Initialize(AnalysisContext context)
+    {
+        base.Initialize(context);
+        context.HandlePropertyDeclaration(Analyze);
+    }
+}
--- a/CliFx.Analyzers/ParameterMustBeLastIfNonScalarAnalyzer.cs
+++ b/CliFx.Analyzers/ParameterMustBeLastIfNonScalarAnalyzer.cs
@@ -5,15 +5,15 @@ using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;

-namespace CliFx.Analyzers
-{
+namespace CliFx.Analyzers;
+
 [DiagnosticAnalyzer(LanguageNames.CSharp)]
 public class ParameterMustBeLastIfNonScalarAnalyzer : AnalyzerBase
 {
    public ParameterMustBeLastIfNonScalarAnalyzer()
        : base(
-                "Parameters of non-scalar types must be last in order",
-                "This parameter has a non-scalar type so it must be last in order (its order must be highest within the command).")
+            "Parameters of non-scalar types must be the last in order",
+            "This parameter has a non-scalar type so it must be the last in order (its order must be highest within the command).")
    {
    }

@@ -22,7 +22,7 @@ namespace CliFx.Analyzers
        type.DisplayNameMatches("System.String") ||
        !type.AllInterfaces
            .Select(i => i.ConstructedFrom)
-                .Any(s => s.DisplayNameMatches("System.Collections.Generic.IEnumerable<T>"));
+            .Any(t => t.DisplayNameMatches("System.Collections.Generic.IEnumerable<T>"));

    private void Analyze(
        SyntaxNodeAnalysisContext context,
@@ -54,7 +54,9 @@ namespace CliFx.Analyzers

            if (otherParameter.Order > parameter.Order)
            {
-                    context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+                context.ReportDiagnostic(
+                    CreateDiagnostic(propertyDeclaration.Identifier.GetLocation())
+                );
            }
        }
    }
@@ -65,4 +67,3 @@ namespace CliFx.Analyzers
        context.HandlePropertyDeclaration(Analyze);
    }
 }
-}
--- a/CliFx.Analyzers/ParameterMustBeSingleIfNonRequiredAnalyzer.cs
+++ b/CliFx.Analyzers/ParameterMustBeSingleIfNonRequiredAnalyzer.cs
@@ -0,0 +1,62 @@
+using System.Linq;
+using CliFx.Analyzers.ObjectModel;
+using CliFx.Analyzers.Utils.Extensions;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace CliFx.Analyzers;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public class 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.")
+    {
+    }
+
+    private void Analyze(
+        SyntaxNodeAnalysisContext context,
+        PropertyDeclarationSyntax propertyDeclaration,
+        IPropertySymbol property)
+    {
+        if (property.ContainingType is null)
+            return;
+
+        var parameter = CommandParameterSymbol.TryResolve(property);
+        if (parameter is null)
+            return;
+
+        if (parameter.IsRequired != false)
+            return;
+
+        var otherProperties = property
+            .ContainingType
+            .GetMembers()
+            .OfType<IPropertySymbol>()
+            .Where(m => !m.Equals(property, SymbolEqualityComparer.Default))
+            .ToArray();
+
+        foreach (var otherProperty in otherProperties)
+        {
+            var otherParameter = CommandParameterSymbol.TryResolve(otherProperty);
+            if (otherParameter is null)
+                continue;
+
+            if (otherParameter.IsRequired == false)
+            {
+                context.ReportDiagnostic(
+                    CreateDiagnostic(propertyDeclaration.Identifier.GetLocation())
+                );
+            }
+        }
+    }
+
+    public override void Initialize(AnalysisContext context)
+    {
+        base.Initialize(context);
+        context.HandlePropertyDeclaration(Analyze);
+    }
+}
--- a/CliFx.Analyzers/ParameterMustBeSingleIfNonScalarAnalyzer.cs
+++ b/CliFx.Analyzers/ParameterMustBeSingleIfNonScalarAnalyzer.cs
@@ -5,8 +5,8 @@ using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;

-namespace CliFx.Analyzers
-{
+namespace CliFx.Analyzers;
+
 [DiagnosticAnalyzer(LanguageNames.CSharp)]
 public class ParameterMustBeSingleIfNonScalarAnalyzer : AnalyzerBase
 {
@@ -22,7 +22,7 @@ namespace CliFx.Analyzers
        type.DisplayNameMatches("System.String") ||
        !type.AllInterfaces
            .Select(i => i.ConstructedFrom)
-                .Any(s => s.DisplayNameMatches("System.Collections.Generic.IEnumerable<T>"));
+            .Any(t => t.DisplayNameMatches("System.Collections.Generic.IEnumerable<T>"));

    private void Analyze(
        SyntaxNodeAnalysisContext context,
@@ -52,7 +52,9 @@ namespace CliFx.Analyzers

            if (!IsScalar(otherProperty.Type))
            {
-                    context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+                context.ReportDiagnostic(
+                    CreateDiagnostic(propertyDeclaration.Identifier.GetLocation())
+                );
            }
        }
    }
@@ -63,4 +65,3 @@ namespace CliFx.Analyzers
        context.HandlePropertyDeclaration(Analyze);
    }
 }
-}
--- a/CliFx.Analyzers/ParameterMustHaveUniqueNameAnalyzer.cs
+++ b/CliFx.Analyzers/ParameterMustHaveUniqueNameAnalyzer.cs
@@ -6,15 +6,16 @@ using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;

-namespace CliFx.Analyzers
-{
+namespace CliFx.Analyzers;
+
 [DiagnosticAnalyzer(LanguageNames.CSharp)]
 public class ParameterMustHaveUniqueNameAnalyzer : AnalyzerBase
 {
    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}'.")
    {
    }

@@ -51,7 +52,12 @@ namespace CliFx.Analyzers

            if (string.Equals(parameter.Name, otherParameter.Name, StringComparison.OrdinalIgnoreCase))
            {
-                    context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+                context.ReportDiagnostic(
+                    CreateDiagnostic(
+                        propertyDeclaration.Identifier.GetLocation(),
+                        parameter.Name
+                    )
+                );
            }
        }
    }
@@ -62,4 +68,3 @@ namespace CliFx.Analyzers
        context.HandlePropertyDeclaration(Analyze);
    }
 }
-}
--- a/CliFx.Analyzers/ParameterMustHaveUniqueOrderAnalyzer.cs
+++ b/CliFx.Analyzers/ParameterMustHaveUniqueOrderAnalyzer.cs
@@ -5,15 +5,16 @@ using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;

-namespace CliFx.Analyzers
-{
+namespace CliFx.Analyzers;
+
 [DiagnosticAnalyzer(LanguageNames.CSharp)]
 public class ParameterMustHaveUniqueOrderAnalyzer : AnalyzerBase
 {
    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}.")
    {
    }

@@ -44,7 +45,12 @@ namespace CliFx.Analyzers

            if (parameter.Order == otherParameter.Order)
            {
-                    context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+                context.ReportDiagnostic(
+                    CreateDiagnostic(
+                        propertyDeclaration.Identifier.GetLocation(),
+                        parameter.Order
+                    )
+                );
            }
        }
    }
@@ -55,4 +61,3 @@ namespace CliFx.Analyzers
        context.HandlePropertyDeclaration(Analyze);
    }
 }
-}
--- a/CliFx.Analyzers/ParameterMustHaveValidConverterAnalyzer.cs
+++ b/CliFx.Analyzers/ParameterMustHaveValidConverterAnalyzer.cs
@@ -5,15 +5,15 @@ using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;

-namespace CliFx.Analyzers
-{
+namespace CliFx.Analyzers;
+
 [DiagnosticAnalyzer(LanguageNames.CSharp)]
 public class ParameterMustHaveValidConverterAnalyzer : AnalyzerBase
 {
    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,19 @@ namespace CliFx.Analyzers
        if (parameter.ConverterType is null)
            return;

-            // We check against an internal interface because checking against a generic class is a pain
-            var converterImplementsInterface = parameter
+        var converterValueType = parameter
            .ConverterType
-                .AllInterfaces
-                .Any(s => s.DisplayNameMatches(SymbolNames.CliFxBindingConverterInterface));
+            .GetBaseTypes()
+            .FirstOrDefault(t => t.ConstructedFrom.DisplayNameMatches(SymbolNames.CliFxBindingConverterClass))?
+            .TypeArguments
+            .FirstOrDefault();

-            if (!converterImplementsInterface)
+        // Value returned by the converter must be assignable to the property type
+        if (converterValueType is null || !property.Type.IsAssignableFrom(converterValueType))
        {
-                context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+            context.ReportDiagnostic(
+                CreateDiagnostic(propertyDeclaration.Identifier.GetLocation())
+            );
        }
    }

@@ -47,4 +51,3 @@ namespace CliFx.Analyzers
        context.HandlePropertyDeclaration(Analyze);
    }
 }
-}
--- a/CliFx.Analyzers/ParameterMustHaveValidValidatorsAnalyzer.cs
+++ b/CliFx.Analyzers/ParameterMustHaveValidValidatorsAnalyzer.cs
@@ -5,15 +5,15 @@ using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;

-namespace CliFx.Analyzers
-{
+namespace CliFx.Analyzers;
+
 [DiagnosticAnalyzer(LanguageNames.CSharp)]
 public class ParameterMustHaveValidValidatorsAnalyzer : AnalyzerBase
 {
    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,18 @@ namespace CliFx.Analyzers

        foreach (var validatorType in parameter.ValidatorTypes)
        {
-                // We check against an internal interface because checking against a generic class is a pain
-                var validatorImplementsInterface = validatorType
-                    .AllInterfaces
-                    .Any(s => s.DisplayNameMatches(SymbolNames.CliFxBindingValidatorInterface));
+            var validatorValueType = validatorType
+                .GetBaseTypes()
+                .FirstOrDefault(t => t.ConstructedFrom.DisplayNameMatches(SymbolNames.CliFxBindingValidatorClass))?
+                .TypeArguments
+                .FirstOrDefault();

-                if (!validatorImplementsInterface)
+            // Value passed to the validator must be assignable from the property type
+            if (validatorValueType is null || !validatorValueType.IsAssignableFrom(property.Type))
            {
-                    context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+                context.ReportDiagnostic(
+                    CreateDiagnostic(propertyDeclaration.Identifier.GetLocation())
+                );

                // No need to report multiple identical diagnostics on the same node
                break;
@@ -49,4 +53,3 @@ namespace CliFx.Analyzers
        context.HandlePropertyDeclaration(Analyze);
    }
 }
-}
--- a/CliFx.Analyzers/SystemConsoleShouldBeAvoidedAnalyzer.cs
+++ b/CliFx.Analyzers/SystemConsoleShouldBeAvoidedAnalyzer.cs
@@ -6,8 +6,8 @@ using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;

-namespace CliFx.Analyzers
-{
+namespace CliFx.Analyzers;
+
 [DiagnosticAnalyzer(LanguageNames.CSharp)]
 public class SystemConsoleShouldBeAvoidedAnalyzer : AnalyzerBase
 {
@@ -65,7 +65,9 @@ namespace CliFx.Analyzers

        if (isConsoleInterfaceAvailable)
        {
-                context.ReportDiagnostic(CreateDiagnostic(systemConsoleMemberAccess.GetLocation()));
+            context.ReportDiagnostic(
+                CreateDiagnostic(systemConsoleMemberAccess.GetLocation())
+            );
        }
    }

@@ -75,4 +77,3 @@ namespace CliFx.Analyzers
        context.RegisterSyntaxNodeAction(Analyze, SyntaxKind.SimpleMemberAccessExpression);
    }
 }
-}
--- a/CliFx.Analyzers/Utils/Extensions/RoslynExtensions.cs
+++ b/CliFx.Analyzers/Utils/Extensions/RoslynExtensions.cs
@@ -1,11 +1,13 @@
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;

-namespace CliFx.Analyzers.Utils.Extensions
-{
+namespace CliFx.Analyzers.Utils.Extensions;
+
 internal static class RoslynExtensions
 {
    public static bool DisplayNameMatches(this ISymbol symbol, string name) =>
@@ -16,6 +18,22 @@ namespace CliFx.Analyzers.Utils.Extensions
            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 bool IsAssignableFrom(this ITypeSymbol target, ITypeSymbol source) =>
+        SymbolEqualityComparer.Default.Equals(target, source) ||
+        source.GetBaseTypes().Contains(target, SymbolEqualityComparer.Default) ||
+        source.AllInterfaces.Contains(target, SymbolEqualityComparer.Default);
+
    public static void HandleClassDeclaration(
        this AnalysisContext analysisContext,
        Action<SyntaxNodeAnalysisContext, ClassDeclarationSyntax, ITypeSymbol> analyze)
@@ -50,4 +68,3 @@ namespace CliFx.Analyzers.Utils.Extensions
        }, SyntaxKind.PropertyDeclaration);
    }
 }
-}
--- a/CliFx.Analyzers/Utils/Extensions/StringExtensions.cs
+++ b/CliFx.Analyzers/Utils/Extensions/StringExtensions.cs
@@ -1,7 +1,7 @@
 using System;

-namespace CliFx.Analyzers.Utils.Extensions
-{
+namespace CliFx.Analyzers.Utils.Extensions;
+
 internal static class StringExtensions
 {
    public static string TrimEnd(
@@ -15,4 +15,3 @@ namespace CliFx.Analyzers.Utils.Extensions
        return str;
    }
 }
-}
--- a/CliFx.Benchmarks/Benchmarks.CliFx.cs
+++ b/CliFx.Benchmarks/Benchmarks.CliFx.cs
@@ -4,8 +4,8 @@ using BenchmarkDotNet.Attributes;
 using CliFx.Attributes;
 using CliFx.Infrastructure;

-namespace CliFx.Benchmarks
-{
+namespace CliFx.Benchmarks;
+
 public partial class Benchmarks
 {
    [Command]
@@ -30,4 +30,3 @@ namespace CliFx.Benchmarks
            .Build()
            .RunAsync(Arguments, new Dictionary<string, string>());
 }
-}
--- a/CliFx.Benchmarks/Benchmarks.Clipr.cs
+++ b/CliFx.Benchmarks/Benchmarks.Clipr.cs
@@ -1,8 +1,8 @@
 using BenchmarkDotNet.Attributes;
 using clipr;

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

-namespace CliFx.Benchmarks
-{
+namespace CliFx.Benchmarks;
+
 public partial class Benchmarks
 {
    public class CoconaCommand
@@ -21,4 +21,3 @@ namespace CliFx.Benchmarks
    [Benchmark(Description = "Cocona")]
    public void ExecuteWithCocona() => CoconaApp.Run<CoconaCommand>(Arguments);
 }
-}
--- a/CliFx.Benchmarks/Benchmarks.CommandLineParser.cs
+++ b/CliFx.Benchmarks/Benchmarks.CommandLineParser.cs
@@ -1,8 +1,8 @@
 using BenchmarkDotNet.Attributes;
 using CommandLine;

-namespace CliFx.Benchmarks
-{
+namespace CliFx.Benchmarks;
+
 public partial class Benchmarks
 {
    public class CommandLineParserCommand
@@ -27,4 +27,3 @@ namespace CliFx.Benchmarks
            .ParseArguments(Arguments, typeof(CommandLineParserCommand))
            .WithParsed<CommandLineParserCommand>(c => c.Execute());
 }
-}
--- a/CliFx.Benchmarks/Benchmarks.McMaster.cs
+++ b/CliFx.Benchmarks/Benchmarks.McMaster.cs
@@ -1,8 +1,8 @@
 using BenchmarkDotNet.Attributes;
 using McMaster.Extensions.CommandLineUtils;

-namespace CliFx.Benchmarks
-{
+namespace CliFx.Benchmarks;
+
 public partial class Benchmarks
 {
    public class McMasterCommand
@@ -22,4 +22,3 @@ namespace CliFx.Benchmarks
    [Benchmark(Description = "McMaster.Extensions.CommandLineUtils")]
    public int ExecuteWithMcMaster() => CommandLineApplication.Execute<McMasterCommand>(Arguments);
 }
-}
--- a/CliFx.Benchmarks/Benchmarks.PowerArgs.cs
+++ b/CliFx.Benchmarks/Benchmarks.PowerArgs.cs
@@ -1,8 +1,8 @@
 using BenchmarkDotNet.Attributes;
 using PowerArgs;

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

-namespace CliFx.Benchmarks
-{
+namespace CliFx.Benchmarks;
+
 public partial class Benchmarks
 {
    public class SystemCommandLineCommand
@@ -41,4 +41,3 @@ namespace CliFx.Benchmarks
    public async Task<int> ExecuteWithSystemCommandLine() =>
        await new SystemCommandLineCommand().ExecuteAsync(Arguments);
 }
-}
--- a/CliFx.Benchmarks/Benchmarks.cs
+++ b/CliFx.Benchmarks/Benchmarks.cs
@@ -3,8 +3,8 @@ using BenchmarkDotNet.Configs;
 using BenchmarkDotNet.Order;
 using BenchmarkDotNet.Running;

-namespace CliFx.Benchmarks
-{
+namespace CliFx.Benchmarks;
+
 [RankColumn]
 [Orderer(SummaryOrderPolicy.FastestToSlowest)]
 public partial class Benchmarks
@@ -14,7 +14,6 @@ namespace CliFx.Benchmarks
    public static void Main() => BenchmarkRunner.Run<Benchmarks>(
        DefaultConfig
            .Instance
-                .With(ConfigOptions.DisableOptimizationsValidator)
+            .WithOptions(ConfigOptions.DisableOptimizationsValidator)
    );
 }
-}
--- a/CliFx.Benchmarks/CliFx.Benchmarks.csproj
+++ b/CliFx.Benchmarks/CliFx.Benchmarks.csproj
@@ -2,15 +2,15 @@

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

  <ItemGroup>
-    <PackageReference Include="BenchmarkDotNet" Version="0.12.0" />
+    <PackageReference Include="BenchmarkDotNet" Version="0.13.1" />
    <PackageReference Include="clipr" Version="1.6.1" />
-    <PackageReference Include="Cocona" Version="1.5.0" />
+    <PackageReference Include="Cocona" Version="2.0.3" />
    <PackageReference Include="CommandLineParser" Version="2.8.0" />
-    <PackageReference Include="McMaster.Extensions.CommandLineUtils" Version="3.1.0" />
+    <PackageReference Include="McMaster.Extensions.CommandLineUtils" Version="4.0.1" />
    <PackageReference Include="PowerArgs" Version="3.6.0" />
    <PackageReference Include="System.CommandLine" Version="2.0.0-beta1.20574.7" />
  </ItemGroup>
--- a/CliFx.Demo/CliFx.Demo.csproj
+++ b/CliFx.Demo/CliFx.Demo.csproj
@@ -2,12 +2,12 @@

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

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

  <ItemGroup>
--- a/CliFx.Demo/Commands/BookAddCommand.cs
+++ b/CliFx.Demo/Commands/BookAddCommand.cs
@@ -6,8 +6,8 @@ using CliFx.Demo.Utils;
 using CliFx.Exceptions;
 using CliFx.Infrastructure;

-namespace CliFx.Demo.Commands
-{
+namespace CliFx.Demo.Commands;
+
 [Command("book add", Description = "Add a book to the library.")]
 public partial class BookAddCommand : ICommand
 {
@@ -67,4 +67,3 @@ namespace CliFx.Demo.Commands
        Random.Next(0, 9)
    );
 }
-}
--- a/CliFx.Demo/Commands/BookCommand.cs
+++ b/CliFx.Demo/Commands/BookCommand.cs
@@ -5,8 +5,8 @@ using CliFx.Demo.Utils;
 using CliFx.Exceptions;
 using CliFx.Infrastructure;

-namespace CliFx.Demo.Commands
-{
+namespace CliFx.Demo.Commands;
+
 [Command("book", Description = "Retrieve a book from the library.")]
 public class BookCommand : ICommand
 {
@@ -32,4 +32,3 @@ namespace CliFx.Demo.Commands
        return default;
    }
 }
-}
--- a/CliFx.Demo/Commands/BookListCommand.cs
+++ b/CliFx.Demo/Commands/BookListCommand.cs
@@ -4,8 +4,8 @@ using CliFx.Demo.Domain;
 using CliFx.Demo.Utils;
 using CliFx.Infrastructure;

-namespace CliFx.Demo.Commands
-{
+namespace CliFx.Demo.Commands;
+
 [Command("book list", Description = "List all books in the library.")]
 public class BookListCommand : ICommand
 {
@@ -34,4 +34,3 @@ namespace CliFx.Demo.Commands
        return default;
    }
 }
-}
--- a/CliFx.Demo/Commands/BookRemoveCommand.cs
+++ b/CliFx.Demo/Commands/BookRemoveCommand.cs
@@ -4,8 +4,8 @@ using CliFx.Demo.Domain;
 using CliFx.Exceptions;
 using CliFx.Infrastructure;

-namespace CliFx.Demo.Commands
-{
+namespace CliFx.Demo.Commands;
+
 [Command("book remove", Description = "Remove a book from the library.")]
 public class BookRemoveCommand : ICommand
 {
@@ -33,4 +33,3 @@ namespace CliFx.Demo.Commands
        return default;
    }
 }
-}
--- a/CliFx.Demo/Domain/Book.cs
+++ b/CliFx.Demo/Domain/Book.cs
@@ -1,7 +1,7 @@
 using System;

-namespace CliFx.Demo.Domain
-{
+namespace CliFx.Demo.Domain;
+
 public class Book
 {
    public string Title { get; }
@@ -20,4 +20,3 @@ namespace CliFx.Demo.Domain
        Isbn = isbn;
    }
 }
-}
--- a/CliFx.Demo/Domain/Isbn.cs
+++ b/CliFx.Demo/Domain/Isbn.cs
@@ -1,7 +1,7 @@
 using System;

-namespace CliFx.Demo.Domain
-{
+namespace CliFx.Demo.Domain;
+
 public partial class Isbn
 {
    public int EanPrefix { get; }
@@ -42,4 +42,3 @@ namespace CliFx.Demo.Domain
        );
    }
 }
-}
--- a/CliFx.Demo/Domain/Library.cs
+++ b/CliFx.Demo/Domain/Library.cs
@@ -2,8 +2,8 @@
 using System.Collections.Generic;
 using System.Linq;

-namespace CliFx.Demo.Domain
-{
+namespace CliFx.Demo.Domain;
+
 public partial class Library
 {
    public IReadOnlyList<Book> Books { get; }
@@ -33,4 +33,3 @@ namespace CliFx.Demo.Domain
 {
    public static Library Empty { get; } = new(Array.Empty<Book>());
 }
-}
--- a/CliFx.Demo/Domain/LibraryProvider.cs
+++ b/CliFx.Demo/Domain/LibraryProvider.cs
@@ -2,8 +2,8 @@
 using System.Linq;
 using Newtonsoft.Json;

-namespace CliFx.Demo.Domain
-{
+namespace CliFx.Demo.Domain;
+
 public class LibraryProvider
 {
    private static string StorageFilePath { get; } = Path.Combine(Directory.GetCurrentDirectory(), "Library.json");
@@ -21,7 +21,7 @@ namespace CliFx.Demo.Domain

        var data = File.ReadAllText(StorageFilePath);

-            return JsonConvert.DeserializeObject<Library>(data);
+        return JsonConvert.DeserializeObject<Library>(data) ?? Library.Empty;
    }

    public Book? TryGetBook(string title) => GetLibrary().Books.FirstOrDefault(b => b.Title == title);
@@ -38,4 +38,3 @@ namespace CliFx.Demo.Domain
        StoreLibrary(updatedLibrary);
    }
 }
-}
--- a/CliFx.Demo/Program.cs
+++ b/CliFx.Demo/Program.cs
@@ -1,15 +1,8 @@
-using System;
-using System.Threading.Tasks;
+using CliFx;
 using CliFx.Demo.Commands;
 using CliFx.Demo.Domain;
 using Microsoft.Extensions.DependencyInjection;

-namespace CliFx.Demo
-{
-    public static class Program
-    {
-        private static IServiceProvider GetServiceProvider()
-        {
 // We use Microsoft.Extensions.DependencyInjection for injecting dependencies in commands
 var services = new ServiceCollection();

@@ -22,15 +15,11 @@ namespace CliFx.Demo
 services.AddTransient<BookRemoveCommand>();
 services.AddTransient<BookListCommand>();

-            return services.BuildServiceProvider();
-        }
+var serviceProvider = services.BuildServiceProvider();

-        public static async Task<int> Main() =>
-            await new CliApplicationBuilder()
+return await new CliApplicationBuilder()
    .SetDescription("Demo application showcasing CliFx features.")
    .AddCommandsFromThisAssembly()
-                .UseTypeActivator(GetServiceProvider().GetRequiredService)
+    .UseTypeActivator(serviceProvider.GetRequiredService)
    .Build()
    .RunAsync();
-    }
-}
--- a/CliFx.Demo/Utils/ConsoleExtensions.cs
+++ b/CliFx.Demo/Utils/ConsoleExtensions.cs
@@ -2,8 +2,8 @@
 using CliFx.Demo.Domain;
 using CliFx.Infrastructure;

-namespace CliFx.Demo.Utils
-{
+namespace CliFx.Demo.Utils;
+
 internal static class ConsoleExtensions
 {
    public static void WriteBook(this ConsoleWriter writer, Book book)
@@ -34,4 +34,3 @@ namespace CliFx.Demo.Utils
            writer.WriteLine(book.Isbn);
    }
 }
-}
--- a/CliFx.Tests.Dummy/CliFx.Tests.Dummy.csproj
+++ b/CliFx.Tests.Dummy/CliFx.Tests.Dummy.csproj
@@ -2,7 +2,7 @@

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

  <ItemGroup>
--- a/CliFx.Tests.Dummy/Commands/ConsoleTestCommand.cs
+++ b/CliFx.Tests.Dummy/Commands/ConsoleTestCommand.cs
@@ -3,8 +3,8 @@ using System.Threading.Tasks;
 using CliFx.Attributes;
 using CliFx.Infrastructure;

-namespace CliFx.Tests.Dummy.Commands
-{
+namespace CliFx.Tests.Dummy.Commands;
+
 [Command("console-test")]
 public class ConsoleTestCommand : ICommand
 {
@@ -21,4 +21,3 @@ namespace CliFx.Tests.Dummy.Commands
        return default;
    }
 }
-}
--- a/CliFx.Tests.Dummy/Commands/EnvironmentTestCommand.cs
+++ b/CliFx.Tests.Dummy/Commands/EnvironmentTestCommand.cs
@@ -2,8 +2,8 @@
 using CliFx.Attributes;
 using CliFx.Infrastructure;

-namespace CliFx.Tests.Dummy.Commands
-{
+namespace CliFx.Tests.Dummy.Commands;
+
 [Command("env-test")]
 public class EnvironmentTestCommand : ICommand
 {
@@ -17,4 +17,3 @@ namespace CliFx.Tests.Dummy.Commands
        return default;
    }
 }
-}
--- a/CliFx.Tests.Dummy/Program.cs
+++ b/CliFx.Tests.Dummy/Program.cs
@@ -1,8 +1,7 @@
 using System.Reflection;
 using System.Threading.Tasks;

-namespace CliFx.Tests.Dummy
-{
+namespace CliFx.Tests.Dummy;
 // This dummy application is used in tests for scenarios
 // that require an external process to properly verify.

@@ -21,4 +20,3 @@ namespace CliFx.Tests.Dummy
            .Build()
            .RunAsync();
 }
-}
--- a/CliFx.Tests/ApplicationSpecs.cs
+++ b/CliFx.Tests/ApplicationSpecs.cs
@@ -6,8 +6,8 @@ using FluentAssertions;
 using Xunit;
 using Xunit.Abstractions;

-namespace CliFx.Tests
-{
+namespace CliFx.Tests;
+
 public class ApplicationSpecs : SpecsBase
 {
    public ApplicationSpecs(ITestOutputHelper testOutput)
@@ -83,4 +83,3 @@ namespace CliFx.Tests
        stdErr.Should().Contain("not a valid command");
    }
 }
-}
--- a/CliFx.Tests/CancellationSpecs.cs
+++ b/CliFx.Tests/CancellationSpecs.cs
@@ -6,8 +6,8 @@ using FluentAssertions;
 using Xunit;
 using Xunit.Abstractions;

-namespace CliFx.Tests
-{
+namespace CliFx.Tests;
+
 public class CancellationSpecs : SpecsBase
 {
    public CancellationSpecs(ITestOutputHelper testOutput)
@@ -64,4 +64,3 @@ public class Command : ICommand
        stdOut.Trim().Should().Be("Cancelled");
    }
 }
-}
--- a/CliFx.Tests/CliFx.Tests.csproj
+++ b/CliFx.Tests/CliFx.Tests.csproj
@@ -1,11 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
-    <TargetFramework>net5.0</TargetFramework>
-    <IsPackable>false</IsPackable>
-    <IsTestProject>true</IsTestProject>
-    <CollectCoverage>true</CollectCoverage>
-    <CoverletOutputFormat>opencover</CoverletOutputFormat>
+    <TargetFramework>net6.0</TargetFramework>
  </PropertyGroup>

  <ItemGroup>
@@ -13,14 +9,15 @@
  </ItemGroup>

  <ItemGroup>
-    <PackageReference Include="CliWrap" Version="3.3.1" />
-    <PackageReference Include="FluentAssertions" Version="5.10.3" />
-    <PackageReference Include="GitHubActionsTestLogger" Version="1.2.0" />
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="3.4.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.9.1" />
+    <PackageReference Include="Basic.Reference.Assemblies" Version="1.2.4" />
+    <PackageReference Include="CliWrap" Version="3.4.1" />
+    <PackageReference Include="FluentAssertions" Version="6.5.1" />
+    <PackageReference Include="GitHubActionsTestLogger" Version="1.3.0" PrivateAssets="all" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.1.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.1.0" />
    <PackageReference Include="xunit" Version="2.4.1" />
    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3" PrivateAssets="all" />
-    <PackageReference Include="coverlet.msbuild" Version="3.0.3" PrivateAssets="all" />
+    <PackageReference Include="coverlet.collector" Version="3.1.2" PrivateAssets="all" />
  </ItemGroup>

  <ItemGroup>
--- a/CliFx.Tests/ConsoleSpecs.cs
+++ b/CliFx.Tests/ConsoleSpecs.cs
@@ -1,15 +1,19 @@
 using System;
 using System.Collections.Generic;
+using System.IO;
+using System.Text;
 using System.Threading.Tasks;
+using CliFx.Infrastructure;
 using CliFx.Tests.Utils;
+using CliFx.Tests.Utils.Extensions;
 using CliWrap;
 using CliWrap.Buffered;
 using FluentAssertions;
 using Xunit;
 using Xunit.Abstractions;

-namespace CliFx.Tests
-{
+namespace CliFx.Tests;
+
 public class ConsoleSpecs : SpecsBase
 {
    public ConsoleSpecs(ITestOutputHelper testOutput)
@@ -77,9 +81,9 @@ public class Command : ICommand
        // Assert
        exitCode.Should().Be(0);

-            Console.OpenStandardInput().Should().NotBe(FakeConsole.Input.BaseStream);
-            Console.OpenStandardOutput().Should().NotBe(FakeConsole.Output.BaseStream);
-            Console.OpenStandardError().Should().NotBe(FakeConsole.Error.BaseStream);
+        Console.OpenStandardInput().Should().NotBeSameAs(FakeConsole.Input.BaseStream);
+        Console.OpenStandardOutput().Should().NotBeSameAs(FakeConsole.Output.BaseStream);
+        Console.OpenStandardError().Should().NotBeSameAs(FakeConsole.Error.BaseStream);

        Console.ForegroundColor.Should().NotBe(ConsoleColor.DarkMagenta);
        Console.BackgroundColor.Should().NotBe(ConsoleColor.DarkMagenta);
@@ -135,5 +139,68 @@ public class Command : ICommand
        stdOut.Trim().Should().Be("Hello world");
        stdErr.Trim().Should().Be("Hello world");
    }
+
+    [Fact]
+    public async Task Fake_console_can_read_key_presses()
+    {
+        // Arrange
+        var commandType = DynamicCommandBuilder.Compile(
+            // language=cs
+            @"
+[Command]
+public class Command : ICommand
+{   
+    public ValueTask ExecuteAsync(IConsole console)
+    {
+        console.Output.WriteLine(console.ReadKey().Key);
+        console.Output.WriteLine(console.ReadKey().Key);
+        console.Output.WriteLine(console.ReadKey().Key);
+
+        return default;
+    }
+}
+");
+
+        var application = new CliApplicationBuilder()
+            .AddCommand(commandType)
+            .UseConsole(FakeConsole)
+            .Build();
+
+        // Act
+        FakeConsole.EnqueueKey(new ConsoleKeyInfo('0', ConsoleKey.D0, false, false, false));
+        FakeConsole.EnqueueKey(new ConsoleKeyInfo('a', ConsoleKey.A, false, false, false));
+        FakeConsole.EnqueueKey(new ConsoleKeyInfo('\0', ConsoleKey.Backspace, false, false, false));
+
+        var exitCode = await application.RunAsync(
+            Array.Empty<string>(),
+            new Dictionary<string, string>()
+        );
+
+        var stdOut = FakeConsole.ReadOutputString();
+
+        // Assert
+        exitCode.Should().Be(0);
+        stdOut.Trim().Should().ConsistOfLines(
+            "D0",
+            "A",
+            "Backspace"
+        );
+    }
+
+    [Fact]
+    public void Console_does_not_emit_preamble_when_used_with_encoding_that_has_it()
+    {
+        // Arrange
+        using var buffer = new MemoryStream();
+        using var consoleWriter = new ConsoleWriter(FakeConsole, buffer, Encoding.UTF8);
+
+        // Act
+        consoleWriter.Write("Hello world");
+        consoleWriter.Flush();
+
+        var output = consoleWriter.Encoding.GetString(buffer.ToArray());
+
+        // Assert
+        output.Should().Be("Hello world");
    }
 }
--- a/CliFx.Tests/ConversionSpecs.cs
+++ b/CliFx.Tests/ConversionSpecs.cs
@@ -6,8 +6,8 @@ using FluentAssertions;
 using Xunit;
 using Xunit.Abstractions;

-namespace CliFx.Tests
-{
+namespace CliFx.Tests;
+
 public class ConversionSpecs : SpecsBase
 {
    public ConversionSpecs(ITestOutputHelper testOutput)
@@ -946,5 +946,47 @@ public class Command : ICommand
        exitCode.Should().NotBe(0);
        stdErr.Should().Contain("Hello world");
    }
+
+    [Fact]
+    public async Task Parameter_or_option_value_conversion_fails_if_the_static_parse_method_throws()
+    {
+        // Arrange
+        var commandType = DynamicCommandBuilder.Compile(
+            // language=cs
+            @"
+public class CustomType
+{
+    public string Value { get; }
+
+    private CustomType(string value) => Value = value;
+
+    public static CustomType Parse(string value) => throw new Exception(""Hello world"");
+}
+
+[Command]
+public class Command : ICommand
+{
+    [CommandOption('f')]
+    public CustomType Foo { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}
+");
+        var application = new CliApplicationBuilder()
+            .AddCommand(commandType)
+            .UseConsole(FakeConsole)
+            .Build();
+
+        // Act
+        var exitCode = await application.RunAsync(
+            new[] {"-f", "bar"},
+            new Dictionary<string, string>()
+        );
+
+        var stdErr = FakeConsole.ReadErrorString();
+
+        // Assert
+        exitCode.Should().NotBe(0);
+        stdErr.Should().Contain("Hello world");
    }
 }
--- a/CliFx.Tests/DirectivesSpecs.cs
+++ b/CliFx.Tests/DirectivesSpecs.cs
@@ -10,8 +10,8 @@ using FluentAssertions;
 using Xunit;
 using Xunit.Abstractions;

-namespace CliFx.Tests
-{
+namespace CliFx.Tests;
+
 public class DirectivesSpecs : SpecsBase
 {
    public DirectivesSpecs(ITestOutputHelper testOutput)
@@ -109,4 +109,3 @@ public class Command : ICommand
        );
    }
 }
-}
--- a/CliFx.Tests/EnvironmentSpecs.cs
+++ b/CliFx.Tests/EnvironmentSpecs.cs
@@ -10,8 +10,8 @@ using FluentAssertions;
 using Xunit;
 using Xunit.Abstractions;

-namespace CliFx.Tests
-{
+namespace CliFx.Tests;
+
 public class EnvironmentSpecs : SpecsBase
 {
    public EnvironmentSpecs(ITestOutputHelper testOutput)
@@ -257,4 +257,3 @@ public class Command : ICommand
        result.StandardOutput.Trim().Should().Be("Hello Mars!");
    }
 }
-}
--- a/CliFx.Tests/ErrorReportingSpecs.cs
+++ b/CliFx.Tests/ErrorReportingSpecs.cs
@@ -7,8 +7,8 @@ using FluentAssertions;
 using Xunit;
 using Xunit.Abstractions;

-namespace CliFx.Tests
-{
+namespace CliFx.Tests;
+
 public class ErrorReportingSpecs : SpecsBase
 {
    public ErrorReportingSpecs(ITestOutputHelper testOutput)
@@ -202,4 +202,3 @@ public class Command : ICommand
        stdErr.Trim().Should().Be("Something went wrong");
    }
 }
-}
--- a/CliFx.Tests/HelpTextSpecs.cs
+++ b/CliFx.Tests/HelpTextSpecs.cs
@@ -7,8 +7,8 @@ using FluentAssertions;
 using Xunit;
 using Xunit.Abstractions;

-namespace CliFx.Tests
-{
+namespace CliFx.Tests;
+
 public class HelpTextSpecs : SpecsBase
 {
    public HelpTextSpecs(ITestOutputHelper testOutput)
@@ -371,6 +371,57 @@ public class Command : ICommand
        );
    }

+    // https://github.com/Tyrrrz/CliFx/issues/117
+    [Fact]
+    public async Task Help_text_shows_usage_format_which_lists_all_parameters_in_specified_order()
+    {
+        // Arrange
+        var commandType = DynamicCommandBuilder.Compile(
+            // language=cs
+            @"
+// Base members appear last in reflection order
+public abstract class CommandBase : ICommand
+{
+    [CommandParameter(0)]
+    public string Foo { get; set; }
+
+    public abstract ValueTask ExecuteAsync(IConsole console);
+}
+
+[Command]
+public class Command : CommandBase
+{
+    [CommandParameter(2)]
+    public IReadOnlyList<string> Baz { get; set; }
+
+    [CommandParameter(1)]
+    public string Bar { get; set; }
+
+    public override ValueTask ExecuteAsync(IConsole console) => default;
+}
+");
+
+        var application = new CliApplicationBuilder()
+            .AddCommand(commandType)
+            .UseConsole(FakeConsole)
+            .Build();
+
+        // Act
+        var exitCode = await application.RunAsync(
+            new[] { "--help" },
+            new Dictionary<string, string>()
+        );
+
+        var stdOut = FakeConsole.ReadOutputString();
+
+        // Assert
+        exitCode.Should().Be(0);
+        stdOut.Should().ContainAllInOrder(
+            "USAGE",
+            "<foo>", "<bar>", "<baz...>"
+        );
+    }
+
    [Fact]
    public async Task Help_text_shows_usage_format_which_lists_all_required_options()
    {
@@ -590,10 +641,55 @@ public enum CustomEnum { One, Two, Three }
 public class Command : ICommand
 {
    [CommandParameter(0)]
-    public List<CustomEnum> Foo { get; set; }
+    public IReadOnlyList<CustomEnum> Foo { get; set; }

    [CommandOption(""bar"")]
-    public List<CustomEnum> Bar { get; set; }
+    public IReadOnlyList<CustomEnum> Bar { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}
+");
+
+        var application = new CliApplicationBuilder()
+            .AddCommand(commandType)
+            .UseConsole(FakeConsole)
+            .Build();
+
+        // Act
+        var exitCode = await application.RunAsync(
+            new[] {"--help"},
+            new Dictionary<string, string>()
+        );
+
+        var stdOut = FakeConsole.ReadOutputString();
+
+        // Assert
+        exitCode.Should().Be(0);
+        stdOut.Should().ContainAllInOrder(
+            "PARAMETERS",
+            "foo", "Choices:", "One", "Two", "Three",
+            "OPTIONS",
+            "--bar", "Choices:", "One", "Two", "Three"
+        );
+    }
+
+    [Fact]
+    public async Task Help_text_shows_all_valid_values_for_nullable_enum_parameters_and_options()
+    {
+        // Arrange
+        var commandType = DynamicCommandBuilder.Compile(
+            // language=cs
+            @"
+public enum CustomEnum { One, Two, Three }
+
+[Command]
+public class Command : ICommand
+{
+    [CommandParameter(0)]
+    public CustomEnum? Foo { get; set; }
+
+    [CommandOption(""bar"")]
+    public IReadOnlyList<CustomEnum?> Bar { get; set; }

    public ValueTask ExecuteAsync(IConsole console) => default;
 }
@@ -920,4 +1016,3 @@ public class SecondCommandSecondChildCommand : ICommand
        stdOut.Trim().Should().Be("v6.9");
    }
 }
-}
--- a/CliFx.Tests/OptionBindingSpecs.cs
+++ b/CliFx.Tests/OptionBindingSpecs.cs
@@ -7,8 +7,8 @@ using FluentAssertions;
 using Xunit;
 using Xunit.Abstractions;

-namespace CliFx.Tests
-{
+namespace CliFx.Tests;
+
 public class OptionBindingSpecs : SpecsBase
 {
    public OptionBindingSpecs(ITestOutputHelper testOutput)
@@ -496,6 +496,83 @@ public class Command : ICommand
        );
    }

+    [Fact]
+    public async Task Option_binding_supports_multiple_inheritance_through_default_interface_members()
+    {
+        // Arrange
+        var commandType = DynamicCommandBuilder.Compile(
+            // language=cs
+            @"
+public static class SharedContext
+{
+    public static int Foo { get; set; }
+
+    public static bool Bar { get; set; }
+}
+
+public interface IHasFoo : ICommand
+{
+    [CommandOption(""foo"")]
+    public int Foo
+    {
+        get => SharedContext.Foo;
+        set => SharedContext.Foo = value;
+    }
+}
+
+public interface IHasBar : ICommand
+{
+    [CommandOption(""bar"")]
+    public bool Bar
+    {
+        get => SharedContext.Bar;
+        set => SharedContext.Bar = value;
+    }
+}
+
+public interface IHasBaz : ICommand
+{
+    public string Baz { get; set; }
+}
+
+[Command]
+public class Command : IHasFoo, IHasBar, IHasBaz
+{
+    [CommandOption(""baz"")]
+    public string Baz { get; set; }
+
+	public ValueTask ExecuteAsync(IConsole console)
+	{
+        console.Output.WriteLine(""Foo = "" + SharedContext.Foo);
+        console.Output.WriteLine(""Bar = "" + SharedContext.Bar);
+        console.Output.WriteLine(""Baz = "" + Baz);
+
+        return default;
+    }
+}
+");
+
+        var application = new CliApplicationBuilder()
+            .AddCommand(commandType)
+            .UseConsole(FakeConsole)
+            .Build();
+
+        // Act
+        var exitCode = await application.RunAsync(
+            new[] { "--foo", "42", "--bar", "--baz", "xyz" }
+        );
+
+        var stdOut = FakeConsole.ReadOutputString();
+
+        // Assert
+        exitCode.Should().Be(0);
+        stdOut.Should().ConsistOfLines(
+            "Foo = 42",
+            "Bar = True",
+            "Baz = xyz"
+        );
+    }
+
    [Fact]
    public async Task Option_binding_does_not_consider_a_negative_number_as_an_option_name_or_short_name()
    {
@@ -705,4 +782,3 @@ public class Command : ICommand
        stdErr.Should().Contain("expects a single argument, but provided with multiple");
    }
 }
-}
--- a/CliFx.Tests/ParameterBindingSpecs.cs
+++ b/CliFx.Tests/ParameterBindingSpecs.cs
@@ -6,8 +6,8 @@ using FluentAssertions;
 using Xunit;
 using Xunit.Abstractions;

-namespace CliFx.Tests
-{
+namespace CliFx.Tests;
+
 public class ParameterBindingSpecs : SpecsBase
 {
    public ParameterBindingSpecs(ITestOutputHelper testOutput)
@@ -120,7 +120,53 @@ public class Command : ICommand
    }

    [Fact]
-        public async Task Parameter_binding_fails_if_one_of_the_parameters_has_not_been_provided()
+    public async Task Parameter_is_not_bound_if_there_are_no_arguments_matching_its_order()
+    {
+        // Arrange
+        var commandType = DynamicCommandBuilder.Compile(
+            // language=cs
+            @"
+[Command]
+public class Command : ICommand
+{
+    [CommandParameter(0)]
+    public string Foo { get; set; }
+
+    [CommandParameter(1, IsRequired = false)]
+    public string Bar { get; set; } = ""xyz"";
+
+    public ValueTask ExecuteAsync(IConsole console)
+    {
+        console.Output.WriteLine(""Foo = "" + Foo);
+        console.Output.WriteLine(""Bar = "" + Bar);
+
+        return default;
+    }
+}");
+
+        var application = new CliApplicationBuilder()
+            .AddCommand(commandType)
+            .UseConsole(FakeConsole)
+            .Build();
+
+        // Act
+        var exitCode = await application.RunAsync(
+            new[] {"abc"},
+            new Dictionary<string, string>()
+        );
+
+        var stdOut = FakeConsole.ReadOutputString();
+
+        // Assert
+        exitCode.Should().Be(0);
+        stdOut.Should().ConsistOfLines(
+            "Foo = abc",
+            "Bar = xyz"
+        );
+    }
+
+    [Fact]
+    public async Task Parameter_binding_fails_if_a_required_parameter_has_not_been_provided()
    {
        // Arrange
        var commandType = DynamicCommandBuilder.Compile(
@@ -153,7 +199,7 @@ public class Command : ICommand

        // Assert
        exitCode.Should().NotBe(0);
-            stdErr.Should().Contain("Missing parameter(s)");
+        stdErr.Should().Contain("Missing required parameter(s)");
    }

    [Fact]
@@ -190,7 +236,7 @@ public class Command : ICommand

        // Assert
        exitCode.Should().NotBe(0);
-            stdErr.Should().Contain("Missing parameter(s)");
+        stdErr.Should().Contain("Missing required parameter(s)");
    }

    [Fact]
@@ -230,4 +276,3 @@ public class Command : ICommand
        stdErr.Should().Contain("Unexpected parameter(s)");
    }
 }
-}
--- a/CliFx.Tests/RoutingSpecs.cs
+++ b/CliFx.Tests/RoutingSpecs.cs
@@ -6,8 +6,8 @@ using FluentAssertions;
 using Xunit;
 using Xunit.Abstractions;

-namespace CliFx.Tests
-{
+namespace CliFx.Tests;
+
 public class RoutingSpecs : SpecsBase
 {
    public RoutingSpecs(ITestOutputHelper testOutput)
@@ -183,4 +183,3 @@ public class NamedChildCommand : ICommand
        stdOut.Trim().Should().Be("cmd child");
    }
 }
-}
--- a/CliFx.Tests/SpecsBase.cs
+++ b/CliFx.Tests/SpecsBase.cs
@@ -3,8 +3,8 @@ using CliFx.Infrastructure;
 using CliFx.Tests.Utils.Extensions;
 using Xunit.Abstractions;

-namespace CliFx.Tests
-{
+namespace CliFx.Tests;
+
 public abstract class SpecsBase : IDisposable
 {
    public ITestOutputHelper TestOutput { get; }
@@ -20,4 +20,3 @@ namespace CliFx.Tests
        FakeConsole.Dispose();
    }
 }
-}
--- a/CliFx.Tests/TypeActivationSpecs.cs
+++ b/CliFx.Tests/TypeActivationSpecs.cs
@@ -7,8 +7,8 @@ using FluentAssertions;
 using Xunit;
 using Xunit.Abstractions;

-namespace CliFx.Tests
-{
+namespace CliFx.Tests;
+
 public class TypeActivationSpecs : SpecsBase
 {
    public TypeActivationSpecs(ITestOutputHelper testOutput)
@@ -162,4 +162,3 @@ public class Command : ICommand
        stdErr.Should().Contain("Failed to create an instance of type");
    }
 }
-}
--- a/CliFx.Tests/Utils/DynamicCommandBuilder.cs
+++ b/CliFx.Tests/Utils/DynamicCommandBuilder.cs
@@ -3,12 +3,13 @@ using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Reflection;
+using Basic.Reference.Assemblies;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.Text;

-namespace CliFx.Tests.Utils
-{
+namespace CliFx.Tests.Utils;
+
 // This class uses Roslyn to compile commands dynamically.
 //
 // It allows us to collocate commands with tests more
@@ -60,16 +61,9 @@ namespace CliFx.Tests.Utils
        var compilation = CSharpCompilation.Create(
            "CliFxTests_DynamicAssembly_" + Guid.NewGuid(),
            new[] {ast},
-                new[]
-                {
-                    MetadataReference.CreateFromFile(Assembly.Load("netstandard").Location),
-                    MetadataReference.CreateFromFile(Assembly.Load("System.Runtime").Location),
-                    MetadataReference.CreateFromFile(typeof(object).Assembly.Location),
-                    MetadataReference.CreateFromFile(typeof(Console).Assembly.Location),
-                    MetadataReference.CreateFromFile(typeof(Enumerable).Assembly.Location),
-                    MetadataReference.CreateFromFile(typeof(DynamicCommandBuilder).Assembly.Location),
-                    MetadataReference.CreateFromFile(typeof(ICommand).Assembly.Location)
-                },
+            ReferenceAssemblies.Net50
+                .Append(MetadataReference.CreateFromFile(typeof(ICommand).Assembly.Location))
+                .Append(MetadataReference.CreateFromFile(typeof(DynamicCommandBuilder).Assembly.Location)),
            // DLL to avoid having to define the Main() method
            new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)
        );
@@ -112,13 +106,13 @@ namespace CliFx.Tests.Utils
        // Return all defined commands
        var commandTypes = generatedAssembly
            .GetTypes()
-                .Where(t => t.IsAssignableTo(typeof(ICommand)))
+            .Where(t => t.IsAssignableTo(typeof(ICommand)) && !t.IsAbstract)
            .ToArray();

        if (commandTypes.Length <= 0)
        {
            throw new InvalidOperationException(
-                    "There are no command definitions in the provide source code."
+                "There are no command definitions in the provided source code."
            );
        }

@@ -132,11 +126,10 @@ namespace CliFx.Tests.Utils
        if (commandTypes.Count > 1)
        {
            throw new InvalidOperationException(
-                    "There are more than one command definitions in the provide source code."
+                "There are more than one command definitions in the provided source code."
            );
        }

        return commandTypes.Single();
    }
 }
-}
--- a/CliFx.Tests/Utils/Extensions/AssertionExtensions.cs
+++ b/CliFx.Tests/Utils/Extensions/AssertionExtensions.cs
@@ -1,24 +1,22 @@
 using System;
 using System.Collections.Generic;
 using FluentAssertions;
-using FluentAssertions.Collections;
 using FluentAssertions.Execution;
 using FluentAssertions.Primitives;

-namespace CliFx.Tests.Utils.Extensions
-{
+namespace CliFx.Tests.Utils.Extensions;
+
 internal static class AssertionExtensions
 {
-        public static AndConstraint<StringCollectionAssertions> ConsistOfLines(
+    public static void ConsistOfLines(
        this StringAssertions assertions,
        IEnumerable<string> lines)
    {
        var actualLines = assertions.Subject.Split(new[] {'\n', '\r'}, StringSplitOptions.RemoveEmptyEntries);
-
-            return actualLines.Should().Equal(lines);
+        actualLines.Should().Equal(lines);
    }

-        public static AndConstraint<StringCollectionAssertions> ConsistOfLines(
+    public static void ConsistOfLines(
        this StringAssertions assertions,
        params string[] lines) =>
        assertions.ConsistOfLines((IEnumerable<string>) lines);
@@ -51,4 +49,3 @@ namespace CliFx.Tests.Utils.Extensions
        params string[] values) =>
        assertions.ContainAllInOrder((IEnumerable<string>) values);
 }
-}
--- a/CliFx.Tests/Utils/Extensions/ConsoleExtensions.cs
+++ b/CliFx.Tests/Utils/Extensions/ConsoleExtensions.cs
@@ -1,8 +1,8 @@
 using CliFx.Infrastructure;
 using Xunit.Abstractions;

-namespace CliFx.Tests.Utils.Extensions
-{
+namespace CliFx.Tests.Utils.Extensions;
+
 internal static class ConsoleExtensions
 {
    public static void DumpToTestOutput(this FakeInMemoryConsole console, ITestOutputHelper testOutputHelper)
@@ -14,4 +14,3 @@ namespace CliFx.Tests.Utils.Extensions
        testOutputHelper.WriteLine(console.ReadErrorString());
    }
 }
-}
--- a/CliFx.Tests/Utils/NoOpCommand.cs
+++ b/CliFx.Tests/Utils/NoOpCommand.cs
@@ -2,11 +2,10 @@
 using CliFx.Attributes;
 using CliFx.Infrastructure;

-namespace CliFx.Tests.Utils
-{
+namespace CliFx.Tests.Utils;
+
 [Command]
 public class NoOpCommand : ICommand
 {
    public ValueTask ExecuteAsync(IConsole console) => default;
 }
-}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Oleksii Holub	59373eadc2	Update version	2022-04-17 00:20:26 +00:00
Oleksii Holub	ed3e4f471e	Improve analyzer diagnostics	2022-04-17 00:01:34 +00:00
Oleksii Holub	41cb8647b5	Produce analyzer errors for invalid generic arguments in converters and validators Closes #103	2022-04-16 22:54:57 +00:00
Oleksii Holub	c7015181e1	Update documentation	2022-04-16 15:34:58 +00:00
Oleksii Holub	86742755e8	Don't wrap default type activator exception if it's not related to constructor	2022-04-16 13:54:44 +00:00
Oleksii Holub	33f95d941d	Use coverlet collector	2022-04-06 21:06:05 +00:00
Oleksii Holub	1328592cb5	Update Readme.md	2022-03-22 10:41:12 -07:00
Oleksii Holub	0711b863ea	Update Readme.md	2022-03-21 10:12:22 -07:00
Oleksii Holub	a2f5cd54be	Add terms of use	2022-03-05 09:46:14 -08:00
Oleksii Holub	7836ec610f	Fuck Russia	2022-02-23 18:23:37 +02:00
Oleksii Holub	2e489927eb	Update NuGet packages	2022-02-21 22:37:10 +02:00
Oleksii Holub	02e8d19e48	Refactor polyfills	2022-02-21 22:35:23 +02:00
Oleksii Holub	eb7107fb0a	Return key in `IConsole.ReadKey(...)` Closes #124	2022-02-19 01:32:58 +02:00
Oleksii Holub	a396009b62	Use expression bodied methods in more places	2022-01-30 19:11:23 +02:00
Oleksii Holub	1d9c7e942c	Update version	2022-01-30 19:09:22 +02:00
Oleksii Holub	0f3abb9db4	Fix thread-safety of ConsoleWriter and ConsoleReader Fixes #123	2022-01-30 19:07:22 +02:00
Oleksii Holub	896482821c	Copy all analyzer dependencies to package	2022-01-21 01:16:59 +02:00
Oleksii Holub	aa3094ee54	Update version	2022-01-16 19:29:50 +02:00
Tyrrrz	712580e3d7	Update my name to match correct spelling	2022-01-15 03:24:06 +02:00
AliReZa Sabouri	c08102f85f	Show default values for optional parameters (#122 )	2022-01-11 05:22:13 -08:00
Tyrrrz	5e684c8b36	Update version	2022-01-11 00:40:30 +02:00
Tyrrrz	300ae70564	Update NuGet packages	2022-01-11 00:39:19 +02:00
Tyrrrz	76f0c77f1e	Update readme	2022-01-11 00:32:56 +02:00
Tyrrrz	0f7cea4ed1	Add some more analyzer tests	2022-01-10 23:56:54 +02:00
Tyrrrz	32ee0b2bd6	Add test for optional parameters	2022-01-10 23:48:38 +02:00
Tyrrrz	4ff1e1d3e1	Cleanup	2022-01-10 23:41:28 +02:00
AliReZa Sabouri	8e96d2701d	Add support for optional parameters (#119 )	2022-01-10 13:11:04 -08:00
Tyrrrz	8e307df231	More cleanup	2022-01-10 16:55:43 +02:00
Tyrrrz	ff38f4916a	Cleanup	2022-01-10 16:45:41 +02:00
AliReZa Sabouri	7cbbb220b4	Fix tests for default interface members (#121 )	2022-01-09 20:29:57 -08:00
AliReZa Sabouri	ae2d4299f0	Add multiple inheritance support through interfaces (#120 )	2022-01-09 08:11:42 -08:00
Tyrrrz	21bc69d116	Make projects not packable by default	2022-01-04 22:48:33 +02:00
Tyrrrz	05a70175cc	Update version	2022-01-04 22:35:59 +02:00
Tyrrrz	33ec2eb3a0	Cleanup	2022-01-04 22:31:50 +02:00
David Fallah	f6ef6cd4c0	Fix ordering of parameters within command help usage (#118 )	2022-01-04 12:12:17 -08:00
Tyrrrz	a9ef693dc1	Share more stuff	2021-12-11 00:11:20 +02:00
Tyrrrz	98bbd666dc	Update badges	2021-12-10 23:22:22 +02:00
Tyrrrz	4e7ed830f8	Move to shared workflows	2021-12-10 23:21:38 +02:00
Tyrrrz	ef87ff76fc	Use top-level statements in demo	2021-12-08 23:52:33 +02:00
Tyrrrz	2feeb21270	C#10ify	2021-12-08 23:43:35 +02:00
Tyrrrz	9990387cfa	Update readme	2021-12-05 22:20:00 +02:00
Tyrrrz	bc1bdca7c6	Update nuget packages	2021-12-05 22:05:21 +02:00
Tyrrrz	2a992d37df	Update readme	2021-12-05 21:59:53 +02:00
Tyrrrz	15c87aecbb	Update CI to .NET 6	2021-11-08 23:34:14 +02:00
Alexey Golub	10a46451ac	Update Readme.md	2021-09-30 15:21:11 -07:00
Alexey Golub	e4c6a4174b	Update readme	2021-09-04 04:20:38 -07:00
Alexey Golub	4c65f7bbee	Update readme	2021-08-30 18:34:26 -07:00
Alexey Golub	5f21de0df5	Refactor webhook in CD	2021-08-28 10:30:58 -07:00
Alexey Golub	9b01b67d98	Update CD	2021-07-28 15:13:09 -07:00
Tyrrrz	4508f5e211	Add Discord	2021-07-26 19:30:54 +03:00
Alex Rosenfeld	f0cbc46df4	Add ReadKey to IConsole (#111 ) Co-authored-by: Alexey Golub <tyrrrrrr@gmail.com>	2021-07-23 11:46:00 -07:00
Alex Rosenfeld	6c96e9e173	Add a clear console function (#110 )	2021-07-19 04:33:07 -07:00
Tyrrrz	51cca36d2a	Update version	2021-07-17 21:37:32 +03:00
Tyrrrz	84672c92f6	Unwrap `TargetInvocationException` to provide more user-friendly errors when binding fails	2021-07-17 21:32:15 +03:00
Tyrrrz	b1d01898b6	Add test for preamble omission	2021-07-10 19:43:21 +03:00
Tyrrrz	441a47a1a8	Update version	2021-07-09 22:23:46 +03:00
Tyrrrz	8abd7219a1	Better shimming in NoPreambleEncoding	2021-07-09 22:00:31 +03:00
Tyrrrz	df73a0bfe8	Update GitHib issue forms	2021-06-24 21:40:08 +03:00
Tyrrrz	55d12dc721	Add readme to package	2021-06-17 20:36:35 +03:00
Alexey Golub	a6ee44c1bb	Fix typo in readme	2021-06-13 06:19:26 -07:00
Tyrrrz	76816e22f1	Use Basic.Reference.Assemblies to simplify reference resolving for dynamic assemblies in tests Note: bumped `Microsoft.CodeAnalysis.CSharp` in test projects, but didn't touch the one in CliFx.Analyzers as it may have unintended side-effects.	2021-05-10 21:10:42 +03:00
Tyrrrz	daf25e59d6	Fix deprecation warning	2021-05-10 21:06:36 +03:00
Tyrrrz	f2b4e53615	Update version	2021-04-24 20:59:10 +03:00
Tyrrrz	2d519ab190	Remove the usage of ConsoleColor.DarkGray because it looks bad in some terminals Fixes #104	2021-04-24 20:48:06 +03:00
Tyrrrz	2d479c9cb6	Refactor	2021-04-24 20:43:35 +03:00
Tyrrrz	2bb7e13e51	Use issue forms	2021-04-22 22:11:39 +03:00
Tyrrrz	6e1dfdcdd4	Update readme	2021-04-22 21:08:16 +03:00
Tyrrrz	5ba647e5c1	Update readme	2021-04-22 21:05:35 +03:00
Tyrrrz	853492695f	Update readme	2021-04-22 21:04:36 +03:00
Robert Dailey	d5d72c7c50	Show choices for nullable enums in enumerable (#105 )	2021-04-22 15:28:33 +03:00
Tyrrrz	d676b5832e	Fix discrepancies in unicode handling between ConsoleWriter and Console.Write(...)	2021-04-21 03:16:18 +03:00
Tyrrrz	28097afc1e	Update NuGet packages	2021-04-18 19:38:35 +03:00
Tyrrrz	fda96586f3	Update NuGet.config	2021-04-17 21:23:19 +03:00
Tyrrrz	fc5af8dbbc	Don't write default value in help text for types that don't override ToString()	2021-04-16 23:28:39 +03:00
Tyrrrz	4835e64388	Remove GHA workarounds	2021-04-13 22:29:15 +03:00
Tyrrrz	0999c33f93	Add NuGet.config	2021-04-13 22:20:07 +03:00