Update version

Closes #127

.github/FUNDING.yml

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

.github/ISSUE_TEMPLATE/config.yml

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

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,17 +0,0 @@
-<!--
-
-**Important:**
-
-Please make sure that there is an existing issue that describes the problem solved by your pull request. If there isn't one, consider creating it first.
-An open issue offers a good place to iron out requirements, discuss possible solutions, and ask questions.
-
-Remember to also:
-
-- Keep your pull request focused and as small as possible. If you want to contribute multiple unrelated changes, please create separate pull requests for them.
-- Follow the coding style and conventions already established by the project. When in doubt about which style to use, ask in the comments to your pull request.
-- If you want to start a discussion regarding a specific change you've made, add a review comment to your own code. This can be used to highlight something important or to seek further input from others.
-
--->
-
-<!-- Please specify the issue addressed by this pull request -->
-Closes #ISSUE_NUMBER

.github/workflows/CD.yml

@@ -1,25 +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 pack CliFx --configuration Release
-
-      - name: Deploy
-        run: dotnet nuget push CliFx/bin/Release/*.nupkg -s nuget.org -k ${{ secrets.NUGET_TOKEN }}

.github/workflows/CI.yml

@@ -1,28 +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 test --configuration Release --logger GitHubActions
-
-      - name: Upload coverage
-        uses: codecov/codecov-action@v1.0.5
-        with:
-          token: ${{ secrets.CODECOV_TOKEN }}

.github/workflows/main.yml

@@ -0,0 +1,13 @@
+name: main
+
+on: [push, pull_request]
+
+jobs:
+  main:
+    uses: Tyrrrz/.github/.github/workflows/nuget.yml@master
+    with:
+      dotnet-version: 6.0.x
+    secrets:
+      CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+      NUGET_TOKEN: ${{ secrets.NUGET_TOKEN }}
+      DISCORD_WEBHOOK: ${{ secrets.DISCORD_WEBHOOK }}

Changelog.md

@@ -1,3 +1,50 @@
+### v2.2.6 (14-Jun-2022)
+
+- Added an overload of `CliApplicationBuilder.UseTypeActivator(...)` that accepts an instance of `IServiceProvider`. This slightly simplifies integration with many DI containers.
+- Fixed minor grammar mistakes in user-facing error messages.
+
+### v2.2.5 (10-May-2022)
+
+- Updated default value resolution for the application executable name. It will now resolve to `myapp.exe` instead of `dotnet myapp.dll` when the application is launched through the EXE apphost on Windows. On other platforms, or when running the application through the .NET CLI, the behavior will be the same as before.
+
+### v2.2.4 (22-Apr-2022)
+
+- Added more contextual information to analyzer diagnostics.
+- Fixed an issue where the analyzer incorrectly reported an error on converters that didn't directly match the target type but were compatible through known built-in conversions.
+- Fixed an issue where MSBuild produced a lot of analyzer-related warnings in certain circumstances.
+
+### v2.2.3 (17-Apr-2022)
+
+- Changed method signature of `IConsole.ReadKey()` to return `ConsoleKeyInfo` instead of `void`. The return type was originally defined as `void` by mistake. This change is source-backwards-compatible but may break on binary level if you were previously calling this method indirectly (i.e. through a library).
+- Added `FakeConsole.EnqueueKey(...)` to facilitate the testing of `IConsole.ReadKey()`. You can use this method to simulate key presses in your application.
+- Extended analyzers that verify the correctness of specified converters and validators. They now also ensure that the specified types are compatible with the type of the underlying property.
+- Improved diagnostics produced by analyzers. Where relevant, highlighted code is now limited to the property or type identifier, instead of the whole property or type declaration. Also extended the diagnostic messages with additional information.
+- Fixed an issue where throwing an exception inside a constructor of a command type resulted in an unrelated error message about the absence of a parameterless constructor.
+
+### v2.2.2 (30-Jan-2022)
+
+- Fixed an issue where `ConsoleWriter` and `ConsoleReader` were not properly thread-safe.
+- Fixed an issue where the analyzer failed to load under certain circumstances when running inside Visual Studio.
+
+### v2.2.1 (16-Jan-2022)
+
+- Fixed an issue which caused help text to not show default values for optional parameters. (Thanks [@AliReZa Sabouri](https://github.com/alirezanet))
+
+### v2.2 (11-Jan-2022)
+
+- Added support for optional parameters. A parameter can be marked as optional by setting `IsRequired = false` on the attribute. Only one parameter is allowed to be optional and such parameter must be the last in order. (Thanks [@AliReZa Sabouri](https://github.com/alirezanet))
+- Fixed an issue where parameters and options bound to properties implemented as default interface members were not working correctly. (Thanks [@AliReZa Sabouri](https://github.com/alirezanet))
+
+### v2.1 (04-Jan-2022)
+
+- Added `IConsole.Clear()` with corresponding implementations in `SystemConsole`, `FakeConsole`, and `FakeInMemoryConsole`. (Thanks [@Alex Rosenfeld](https://github.com/alexrosenfeld10))
+- Added `IConsole.ReadKey()` with corresponding implementations in `SystemConsole`, `FakeConsole`, and `FakeInMemoryConsole`. (Thanks [@Alex Rosenfeld](https://github.com/alexrosenfeld10))
+- Fixed an issue that caused parameters to appear out of order in the usage format section of the help text. (Thanks [@David Fallah](https://github.com/TAGC))
+
+### v2.0.6 (17-Jul-2021)
+
+- Fixed an issue where an exception thrown via reflection during parameter or option binding resulted in `Exception has been thrown by the target of an invocation` error instead of a more useful message. Such exceptions will now be unwrapped to provide better user experience.
+
 ### v2.0.5 (09-Jul-2021)
 
 - Fixed an issue where calling `IConsole.Output.Encoding.EncodingName` and some other members threw an exception.
@@ -27,7 +74,7 @@
 ### v2.0 (21-Mar-2021)
 
 > Note: this major release includes many breaking changes.
-Please refer to the readme to find updated instructions and usage examples.
+> Please refer to the readme to find updated instructions and usage examples.
 
 - Renamed property `EnvironmentVariableName` to `EnvironmentVariable` on `CommandOption` attribute.
 - Removed most of schema validation checks that used to take place during application startup. Going forward, CliFx will be relying solely on its built-in set of Roslyn analyzers to catch common errors in command configuration.

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

@@ -1,11 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net5.0</TargetFramework>
-    <IsPackable>false</IsPackable>
-    <IsTestProject>true</IsTestProject>
-    <CollectCoverage>true</CollectCoverage>
-    <CoverletOutputFormat>opencover</CoverletOutputFormat>
+    <TargetFramework>net6.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
@@ -13,14 +9,14 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Basic.Reference.Assemblies" Version="1.1.2" />
-    <PackageReference Include="GitHubActionsTestLogger" Version="1.2.0" />
-    <PackageReference Include="FluentAssertions" Version="5.10.3" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.9.4" />
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="3.9.0" />
+    <PackageReference Include="Basic.Reference.Assemblies" Version="1.2.4" />
+    <PackageReference Include="GitHubActionsTestLogger" Version="2.0.0" PrivateAssets="all" />
+    <PackageReference Include="FluentAssertions" Version="6.7.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.2.0" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.2.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="xunit.runner.visualstudio" Version="2.4.5" PrivateAssets="all" />
+    <PackageReference Include="coverlet.collector" Version="3.1.2" PrivateAssets="all" />
   </ItemGroup>
 
   <ItemGroup>

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

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

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();
     }
 }
-}

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

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

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

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

CliFx.Analyzers.Tests/OptionMustHaveValidConverterAnalyzerSpecs.cs

@@ -2,14 +2,14 @@
 using Microsoft.CodeAnalysis.Diagnostics;
 using Xunit;
 
-namespace CliFx.Analyzers.Tests
-{
+namespace CliFx.Analyzers.Tests;
+
 public class OptionMustHaveValidConverterAnalyzerSpecs
 {
     private static DiagnosticAnalyzer Analyzer { get; } = new OptionMustHaveValidConverterAnalyzer();
 
     [Fact]
-        public void Analyzer_reports_an_error_if_the_specified_option_converter_does_not_derive_from_BindingConverter()
+    public void Analyzer_reports_an_error_if_an_option_has_a_converter_that_does_not_derive_from_BindingConverter()
     {
         // Arrange
         // language=cs
@@ -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_an_option_has_a_converter_that_does_not_derive_from_a_compatible_BindingConverter()
+    {
+        // Arrange
+        // language=cs
+        const string code = @"
+public class MyConverter : BindingConverter<int>
+{
+    public override int Convert(string rawValue) => 42;
+}
+
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandOption(""foo"", Converter = typeof(MyConverter))]
+    public string Foo { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_an_option_has_a_converter_that_derives_from_a_compatible_BindingConverter()
     {
         // Arrange
         // language=cs
@@ -56,6 +80,54 @@ public class MyCommand : ICommand
         Analyzer.Should().NotProduceDiagnostics(code);
     }
 
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_nullable_option_has_a_converter_that_derives_from_a_compatible_BindingConverter()
+    {
+        // Arrange
+        // language=cs
+        const string code = @"
+public class MyConverter : BindingConverter<int>
+{
+    public override int Convert(string rawValue) => 42;
+}
+
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandOption(""foo"", Converter = typeof(MyConverter))]
+    public int? Foo { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_non_scalar_option_has_a_converter_that_derives_from_a_compatible_BindingConverter()
+    {
+        // Arrange
+        // language=cs
+        const string code = @"
+public class MyConverter : BindingConverter<string>
+{
+    public override string Convert(string rawValue) => rawValue;
+}
+
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandOption(""foo"", Converter = typeof(MyConverter))]
+    public IReadOnlyList<string> Foo { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
     [Fact]
     public void Analyzer_does_not_report_an_error_if_an_option_does_not_have_a_converter()
     {
@@ -93,4 +165,3 @@ public class MyCommand : ICommand
         Analyzer.Should().NotProduceDiagnostics(code);
     }
 }
-}

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

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

CliFx.Analyzers.Tests/OptionMustHaveValidValidatorsAnalyzerSpecs.cs

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

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

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

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

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

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

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

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

CliFx.Analyzers.Tests/ParameterMustHaveValidConverterAnalyzerSpecs.cs

@@ -2,14 +2,14 @@
 using Microsoft.CodeAnalysis.Diagnostics;
 using Xunit;
 
-namespace CliFx.Analyzers.Tests
-{
+namespace CliFx.Analyzers.Tests;
+
 public class ParameterMustHaveValidConverterAnalyzerSpecs
 {
     private static DiagnosticAnalyzer Analyzer { get; } = new ParameterMustHaveValidConverterAnalyzer();
 
     [Fact]
-        public void Analyzer_reports_an_error_if_the_specified_parameter_converter_does_not_derive_from_BindingConverter()
+    public void Analyzer_reports_an_error_if_a_parameter_has_a_converter_that_does_not_derive_from_BindingConverter()
     {
         // Arrange
         // language=cs
@@ -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_a_parameter_has_a_converter_that_does_not_derive_from_a_compatible_BindingConverter()
+    {
+        // Arrange
+        // language=cs
+        const string code = @"
+public class MyConverter : BindingConverter<int>
+{
+    public override int Convert(string rawValue) => 42;
+}
+
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandParameter(0, Converter = typeof(MyConverter))]
+    public string Foo { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_parameter_has_a_converter_that_derives_from_a_compatible_BindingConverter()
     {
         // Arrange
         // language=cs
@@ -56,6 +81,54 @@ public class MyCommand : ICommand
         Analyzer.Should().NotProduceDiagnostics(code);
     }
 
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_nullable_parameter_has_a_converter_that_derives_from_a_compatible_BindingConverter()
+    {
+        // Arrange
+        // language=cs
+        const string code = @"
+public class MyConverter : BindingConverter<int>
+{
+    public override int Convert(string rawValue) => 42;
+}
+
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandOption(""foo"", Converter = typeof(MyConverter))]
+    public int? Foo { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_non_scalar_parameter_has_a_converter_that_derives_from_a_compatible_BindingConverter()
+    {
+        // Arrange
+        // language=cs
+        const string code = @"
+public class MyConverter : BindingConverter<string>
+{
+    public override string Convert(string rawValue) => rawValue;
+}
+
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandParameter(0, Converter = typeof(MyConverter))]
+    public IReadOnlyList<string> Foo { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
     [Fact]
     public void Analyzer_does_not_report_an_error_if_a_parameter_does_not_have_a_converter()
     {
@@ -93,4 +166,3 @@ public class MyCommand : ICommand
         Analyzer.Should().NotProduceDiagnostics(code);
     }
 }
-}

CliFx.Analyzers.Tests/ParameterMustHaveValidValidatorsAnalyzerSpecs.cs

@@ -2,14 +2,14 @@
 using Microsoft.CodeAnalysis.Diagnostics;
 using Xunit;
 
-namespace CliFx.Analyzers.Tests
-{
+namespace CliFx.Analyzers.Tests;
+
 public class ParameterMustHaveValidValidatorsAnalyzerSpecs
 {
     private static DiagnosticAnalyzer Analyzer { get; } = new ParameterMustHaveValidValidatorsAnalyzer();
 
     [Fact]
-        public void Analyzer_reports_an_error_if_one_of_the_specified_parameter_validators_does_not_derive_from_BindingValidator()
+    public void Analyzer_reports_an_error_a_parameter_has_a_validator_that_does_not_derive_from_BindingValidator()
     {
         // Arrange
         // language=cs
@@ -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_a_parameter_has_a_validator_that_does_not_derive_from_a_compatible_BindingValidator()
+    {
+        // Arrange
+        // language=cs
+        const string code = @"
+public class MyValidator : BindingValidator<int>
+{
+    public override BindingValidationError Validate(int value) => Ok();
+}
+
+[Command]
+public class MyCommand : ICommand
+{
+    [CommandParameter(0, Validators = new[] {typeof(MyValidator)})]
+    public string Foo { get; set; }
+
+    public ValueTask ExecuteAsync(IConsole console) => default;
+}";
+
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_parameter_has_validators_that_all_derive_from_compatible_BindingValidators()
     {
         // Arrange
         // language=cs
@@ -93,4 +117,3 @@ public class MyCommand : ICommand
         Analyzer.Should().NotProduceDiagnostics(code);
     }
 }
-}

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

CliFx.Analyzers.Tests/Utils/AnalyzerAssertions.cs

@@ -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";
@@ -101,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();
 
@@ -125,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());
         });
@@ -138,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();
 
@@ -165,4 +171,3 @@ namespace CliFx.Analyzers.Tests.Utils
 {
     public static AnalyzerAssertions Should(this DiagnosticAnalyzer analyzer) => new(analyzer);
 }
-}

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

CliFx.Analyzers/CliFx.Analyzers.csproj

@@ -2,12 +2,15 @@
 
   <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" />
+    <!-- Keep this dependency as low as possible since we can't bundle it -->
+    <!-- https://github.com/Tyrrrz/CliFx/issues/127 -->
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="3.8.0" PrivateAssets="all" />
   </ItemGroup>
 
 </Project>

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

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

CliFx.Analyzers/ObjectModel/CommandOptionSymbol.cs

@@ -1,12 +1,14 @@
 using System.Collections.Generic;
-using Microsoft.CodeAnalysis;
 using System.Linq;
 using CliFx.Analyzers.Utils.Extensions;
+using Microsoft.CodeAnalysis;
 
-namespace CliFx.Analyzers.ObjectModel
-{
-    internal partial class CommandOptionSymbol
+namespace CliFx.Analyzers.ObjectModel;
+
+internal partial class CommandOptionSymbol : ICommandMemberSymbol
 {
+    public IPropertySymbol Property { get; }
+
     public string? Name { get; }
 
     public char? ShortName { get; }
@@ -16,11 +18,13 @@ namespace CliFx.Analyzers.ObjectModel
     public IReadOnlyList<ITypeSymbol> ValidatorTypes { get; }
 
     public CommandOptionSymbol(
+        IPropertySymbol property,
         string? name,
         char? shortName,
         ITypeSymbol? converterType,
         IReadOnlyList<ITypeSymbol> validatorTypes)
     {
+        Property = property;
         Name = name;
         ShortName = shortName;
         ConverterType = converterType;
@@ -30,22 +34,25 @@ namespace CliFx.Analyzers.ObjectModel
 
 internal partial class CommandOptionSymbol
 {
-        private static AttributeData? TryGetOptionAttribute(IPropertySymbol property) =>
-            property
+    private static AttributeData? TryGetOptionAttribute(IPropertySymbol property) => property
         .GetAttributes()
-                .FirstOrDefault(a => a.AttributeClass.DisplayNameMatches(SymbolNames.CliFxCommandOptionAttribute));
+        .FirstOrDefault(a => a.AttributeClass?.DisplayNameMatches(SymbolNames.CliFxCommandOptionAttribute) == true);
 
-        private static CommandOptionSymbol FromAttribute(AttributeData attribute)
+    public static CommandOptionSymbol? TryResolve(IPropertySymbol property)
     {
+        var attribute = TryGetOptionAttribute(property);
+        if (attribute is null)
+            return null;
+
         var name = attribute
             .ConstructorArguments
-                .Where(a => a.Type.DisplayNameMatches("string") || a.Type.DisplayNameMatches("System.String"))
+            .Where(a => a.Type?.SpecialType == SpecialType.System_String)
             .Select(a => a.Value)
             .FirstOrDefault() as string;
 
         var shortName = attribute
             .ConstructorArguments
-                .Where(a => a.Type.DisplayNameMatches("char") || a.Type.DisplayNameMatches("System.Char"))
+            .Where(a => a.Type?.SpecialType == SpecialType.System_Char)
             .Select(a => a.Value)
             .FirstOrDefault() as char?;
 
@@ -64,20 +71,9 @@ namespace CliFx.Analyzers.ObjectModel
             .Cast<ITypeSymbol>()
             .ToArray();
 
-            return new CommandOptionSymbol(name, shortName, converter, validators);
-        }
-
-        public static CommandOptionSymbol? TryResolve(IPropertySymbol property)
-        {
-            var attribute = TryGetOptionAttribute(property);
-
-            if (attribute is null)
-                return null;
-
-            return FromAttribute(attribute);
+        return new CommandOptionSymbol(property, name, shortName, converter, validators);
     }
 
     public static bool IsOptionProperty(IPropertySymbol property) =>
         TryGetOptionAttribute(property) is not null;
 }
-}

CliFx.Analyzers/ObjectModel/CommandParameterSymbol.cs

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

CliFx.Analyzers/ObjectModel/ICommandMemberSymbol.cs

@@ -0,0 +1,21 @@
+using System.Collections.Generic;
+using CliFx.Analyzers.Utils.Extensions;
+using Microsoft.CodeAnalysis;
+
+namespace CliFx.Analyzers.ObjectModel;
+
+internal interface ICommandMemberSymbol
+{
+    IPropertySymbol Property { get; }
+
+    ITypeSymbol? ConverterType { get; }
+
+    IReadOnlyList<ITypeSymbol> ValidatorTypes { get; }
+}
+
+internal static class CommandMemberSymbolExtensions
+{
+    public static bool IsScalar(this ICommandMemberSymbol member) =>
+        member.Property.Type.SpecialType == SpecialType.System_String ||
+        member.Property.Type.TryGetEnumerableUnderlyingType() is null;
+}

CliFx.Analyzers/ObjectModel/SymbolNames.cs

@@ -1,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>";
 }
-}

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

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

CliFx.Analyzers/OptionMustHaveUniqueNameAnalyzer.cs

@@ -6,15 +6,17 @@ using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 
-namespace CliFx.Analyzers
-{
+namespace CliFx.Analyzers;
+
 [DiagnosticAnalyzer(LanguageNames.CSharp)]
 public class OptionMustHaveUniqueNameAnalyzer : AnalyzerBase
 {
     public OptionMustHaveUniqueNameAnalyzer()
         : base(
             "Options must have unique names",
-                "This option's name must be unique within the command (comparison IS NOT case sensitive).")
+            "This option's name must be unique within the command (comparison IS NOT case sensitive). " +
+            "Specified name: `{0}`. " +
+            "Property bound to another option with the same name: `{1}`.")
     {
     }
 
@@ -51,7 +53,13 @@ namespace CliFx.Analyzers
 
             if (string.Equals(option.Name, otherOption.Name, StringComparison.OrdinalIgnoreCase))
             {
-                    context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+                context.ReportDiagnostic(
+                    CreateDiagnostic(
+                        propertyDeclaration.Identifier.GetLocation(),
+                        option.Name,
+                        otherProperty.Name
+                    )
+                );
             }
         }
     }
@@ -62,4 +70,3 @@ namespace CliFx.Analyzers
         context.HandlePropertyDeclaration(Analyze);
     }
 }
-}

CliFx.Analyzers/OptionMustHaveUniqueShortNameAnalyzer.cs

@@ -5,15 +5,17 @@ using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 
-namespace CliFx.Analyzers
-{
+namespace CliFx.Analyzers;
+
 [DiagnosticAnalyzer(LanguageNames.CSharp)]
 public class OptionMustHaveUniqueShortNameAnalyzer : AnalyzerBase
 {
     public OptionMustHaveUniqueShortNameAnalyzer()
         : base(
             "Options must have unique short names",
-                "This option's short name must be unique within the command (comparison IS case sensitive).")
+            "This option's short name must be unique within the command (comparison IS case sensitive). " +
+            "Specified short name: `{0}` " +
+            "Property bound to another option with the same short name: `{1}`.")
     {
     }
 
@@ -50,7 +52,13 @@ namespace CliFx.Analyzers
 
             if (option.ShortName == otherOption.ShortName)
             {
-                    context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+                context.ReportDiagnostic(
+                    CreateDiagnostic(
+                        propertyDeclaration.Identifier.GetLocation(),
+                        option.ShortName,
+                        otherProperty.Name
+                    )
+                );
             }
         }
     }
@@ -61,4 +69,3 @@ namespace CliFx.Analyzers
         context.HandlePropertyDeclaration(Analyze);
     }
 }
-}

CliFx.Analyzers/OptionMustHaveValidConverterAnalyzer.cs

@@ -5,15 +5,15 @@ using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 
-namespace CliFx.Analyzers
-{
+namespace CliFx.Analyzers;
+
 [DiagnosticAnalyzer(LanguageNames.CSharp)]
 public class OptionMustHaveValidConverterAnalyzer : AnalyzerBase
 {
     public OptionMustHaveValidConverterAnalyzer()
         : base(
             $"Option converters must derive from `{SymbolNames.CliFxBindingConverterClass}`",
-                $"Converter specified for this option must derive from `{SymbolNames.CliFxBindingConverterClass}`.")
+            $"Converter specified for this option must derive from a compatible `{SymbolNames.CliFxBindingConverterClass}`.")
     {
     }
 
@@ -29,15 +29,28 @@ namespace CliFx.Analyzers
         if (option.ConverterType is null)
             return;
 
-            // We check against an internal interface because checking against a generic class is a pain
-            var converterImplementsInterface = option
+        var converterValueType = option
             .ConverterType
-                .AllInterfaces
-                .Any(s => s.DisplayNameMatches(SymbolNames.CliFxBindingConverterInterface));
+            .GetBaseTypes()
+            .FirstOrDefault(t => t.ConstructedFrom.DisplayNameMatches(SymbolNames.CliFxBindingConverterClass))?
+            .TypeArguments
+            .FirstOrDefault();
 
-            if (!converterImplementsInterface)
+        // Value returned by the converter must be assignable to the property type
+        var isCompatible =
+            converterValueType is not null && (option.IsScalar()
+                // Scalar
+                ? context.Compilation.IsAssignable(converterValueType, property.Type)
+                // Non-scalar (assume we can handle all IEnumerable types for simplicity)
+                : property.Type.TryGetEnumerableUnderlyingType() is { } enumerableUnderlyingType &&
+                  context.Compilation.IsAssignable(converterValueType, enumerableUnderlyingType)
+            );
+
+        if (!isCompatible)
         {
-                context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+            context.ReportDiagnostic(
+                CreateDiagnostic(propertyDeclaration.Identifier.GetLocation())
+            );
         }
     }
 
@@ -47,4 +60,3 @@ namespace CliFx.Analyzers
         context.HandlePropertyDeclaration(Analyze);
     }
 }
-}

CliFx.Analyzers/OptionMustHaveValidNameAnalyzer.cs

@@ -4,15 +4,16 @@ using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 
-namespace CliFx.Analyzers
-{
+namespace CliFx.Analyzers;
+
 [DiagnosticAnalyzer(LanguageNames.CSharp)]
 public class OptionMustHaveValidNameAnalyzer : AnalyzerBase
 {
     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);
     }
 }
-}

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

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

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

CliFx.Analyzers/ParameterMustBeLastIfNonRequiredAnalyzer.cs

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

CliFx.Analyzers/ParameterMustBeLastIfNonScalarAnalyzer.cs

@@ -5,25 +5,19 @@ 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). " +
+            "Property bound to another non-scalar parameter: `{0}`.")
     {
     }
 
-        private static bool IsScalar(ITypeSymbol type) =>
-            type.DisplayNameMatches("string") ||
-            type.DisplayNameMatches("System.String") ||
-            !type.AllInterfaces
-                .Select(i => i.ConstructedFrom)
-                .Any(s => s.DisplayNameMatches("System.Collections.Generic.IEnumerable<T>"));
-
     private void Analyze(
         SyntaxNodeAnalysisContext context,
         PropertyDeclarationSyntax propertyDeclaration,
@@ -32,13 +26,13 @@ namespace CliFx.Analyzers
         if (property.ContainingType is null)
             return;
 
-            if (IsScalar(property.Type))
-                return;
-
         var parameter = CommandParameterSymbol.TryResolve(property);
         if (parameter is null)
             return;
 
+        if (parameter.IsScalar())
+            return;
+
         var otherProperties = property
             .ContainingType
             .GetMembers()
@@ -54,7 +48,12 @@ namespace CliFx.Analyzers
 
             if (otherParameter.Order > parameter.Order)
             {
-                    context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+                context.ReportDiagnostic(
+                    CreateDiagnostic(
+                        propertyDeclaration.Identifier.GetLocation(),
+                        otherProperty.Name
+                    )
+                );
             }
         }
     }
@@ -65,4 +64,3 @@ namespace CliFx.Analyzers
         context.HandlePropertyDeclaration(Analyze);
     }
 }
-}

CliFx.Analyzers/ParameterMustBeSingleIfNonRequiredAnalyzer.cs

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

CliFx.Analyzers/ParameterMustBeSingleIfNonScalarAnalyzer.cs

@@ -5,25 +5,19 @@ 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
 {
     public ParameterMustBeSingleIfNonScalarAnalyzer()
         : base(
             "Parameters of non-scalar types are limited to one per command",
-                "This parameter has a non-scalar type so it must be the only such parameter in the command.")
+            "This parameter has a non-scalar type so it must be the only such parameter in the command. " +
+            "Property bound to another non-scalar parameter: `{0}`.")
     {
     }
 
-        private static bool IsScalar(ITypeSymbol type) =>
-            type.DisplayNameMatches("string") ||
-            type.DisplayNameMatches("System.String") ||
-            !type.AllInterfaces
-                .Select(i => i.ConstructedFrom)
-                .Any(s => s.DisplayNameMatches("System.Collections.Generic.IEnumerable<T>"));
-
     private void Analyze(
         SyntaxNodeAnalysisContext context,
         PropertyDeclarationSyntax propertyDeclaration,
@@ -32,10 +26,11 @@ namespace CliFx.Analyzers
         if (property.ContainingType is null)
             return;
 
-            if (!CommandParameterSymbol.IsParameterProperty(property))
+        var parameter = CommandParameterSymbol.TryResolve(property);
+        if (parameter is null)
             return;
 
-            if (IsScalar(property.Type))
+        if (parameter.IsScalar())
             return;
 
         var otherProperties = property
@@ -47,12 +42,18 @@ namespace CliFx.Analyzers
 
         foreach (var otherProperty in otherProperties)
         {
-                if (!CommandParameterSymbol.IsParameterProperty(otherProperty))
+            var otherParameter = CommandParameterSymbol.TryResolve(otherProperty);
+            if (otherParameter is null)
                 continue;
 
-                if (!IsScalar(otherProperty.Type))
+            if (!otherParameter.IsScalar())
             {
-                    context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+                context.ReportDiagnostic(
+                    CreateDiagnostic(
+                        propertyDeclaration.Identifier.GetLocation(),
+                        otherProperty.Name
+                    )
+                );
             }
         }
     }
@@ -63,4 +64,3 @@ namespace CliFx.Analyzers
         context.HandlePropertyDeclaration(Analyze);
     }
 }
-}

CliFx.Analyzers/ParameterMustHaveUniqueNameAnalyzer.cs

@@ -6,15 +6,17 @@ using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 
-namespace CliFx.Analyzers
-{
+namespace CliFx.Analyzers;
+
 [DiagnosticAnalyzer(LanguageNames.CSharp)]
 public class ParameterMustHaveUniqueNameAnalyzer : AnalyzerBase
 {
     public ParameterMustHaveUniqueNameAnalyzer()
         : base(
             "Parameters must have unique names",
-                "This parameter's name must be unique within the command (comparison IS NOT case sensitive).")
+            "This parameter's name must be unique within the command (comparison IS NOT case sensitive). " +
+            "Specified name: `{0}`. " +
+            "Property bound to another parameter with the same name: `{1}`.")
     {
     }
 
@@ -51,7 +53,13 @@ namespace CliFx.Analyzers
 
             if (string.Equals(parameter.Name, otherParameter.Name, StringComparison.OrdinalIgnoreCase))
             {
-                    context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+                context.ReportDiagnostic(
+                    CreateDiagnostic(
+                        propertyDeclaration.Identifier.GetLocation(),
+                        parameter.Name,
+                        otherProperty.Name
+                    )
+                );
             }
         }
     }
@@ -62,4 +70,3 @@ namespace CliFx.Analyzers
         context.HandlePropertyDeclaration(Analyze);
     }
 }
-}

CliFx.Analyzers/ParameterMustHaveUniqueOrderAnalyzer.cs

@@ -5,15 +5,17 @@ using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 
-namespace CliFx.Analyzers
-{
+namespace CliFx.Analyzers;
+
 [DiagnosticAnalyzer(LanguageNames.CSharp)]
 public class ParameterMustHaveUniqueOrderAnalyzer : AnalyzerBase
 {
     public ParameterMustHaveUniqueOrderAnalyzer()
         : base(
             "Parameters must have unique order",
-                "This parameter's order must be unique within the command.")
+            "This parameter's order must be unique within the command. " +
+            "Specified order: {0}. " +
+            "Property bound to another parameter with the same order: `{1}`.")
     {
     }
 
@@ -44,7 +46,13 @@ namespace CliFx.Analyzers
 
             if (parameter.Order == otherParameter.Order)
             {
-                    context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+                context.ReportDiagnostic(
+                    CreateDiagnostic(
+                        propertyDeclaration.Identifier.GetLocation(),
+                        parameter.Order,
+                        otherProperty.Name
+                    )
+                );
             }
         }
     }
@@ -55,4 +63,3 @@ namespace CliFx.Analyzers
         context.HandlePropertyDeclaration(Analyze);
     }
 }
-}

CliFx.Analyzers/ParameterMustHaveValidConverterAnalyzer.cs

@@ -5,15 +5,15 @@ using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 
-namespace CliFx.Analyzers
-{
+namespace CliFx.Analyzers;
+
 [DiagnosticAnalyzer(LanguageNames.CSharp)]
 public class ParameterMustHaveValidConverterAnalyzer : AnalyzerBase
 {
     public ParameterMustHaveValidConverterAnalyzer()
         : base(
             $"Parameter converters must derive from `{SymbolNames.CliFxBindingConverterClass}`",
-                $"Converter specified for this parameter must derive from `{SymbolNames.CliFxBindingConverterClass}`.")
+            $"Converter specified for this parameter must derive from a compatible `{SymbolNames.CliFxBindingConverterClass}`.")
     {
     }
 
@@ -29,15 +29,28 @@ namespace CliFx.Analyzers
         if (parameter.ConverterType is null)
             return;
 
-            // We check against an internal interface because checking against a generic class is a pain
-            var converterImplementsInterface = parameter
+        var converterValueType = parameter
             .ConverterType
-                .AllInterfaces
-                .Any(s => s.DisplayNameMatches(SymbolNames.CliFxBindingConverterInterface));
+            .GetBaseTypes()
+            .FirstOrDefault(t => t.ConstructedFrom.DisplayNameMatches(SymbolNames.CliFxBindingConverterClass))?
+            .TypeArguments
+            .FirstOrDefault();
 
-            if (!converterImplementsInterface)
+        // Value returned by the converter must be assignable to the property type
+        var isCompatible =
+            converterValueType is not null && (parameter.IsScalar()
+                // Scalar
+                ? context.Compilation.IsAssignable(converterValueType, property.Type)
+                // Non-scalar (assume we can handle all IEnumerable types for simplicity)
+                : property.Type.TryGetEnumerableUnderlyingType() is { } enumerableUnderlyingType &&
+                  context.Compilation.IsAssignable(converterValueType, enumerableUnderlyingType)
+            );
+
+        if (!isCompatible)
         {
-                context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+            context.ReportDiagnostic(
+                CreateDiagnostic(propertyDeclaration.Identifier.GetLocation())
+            );
         }
     }
 
@@ -47,4 +60,3 @@ namespace CliFx.Analyzers
         context.HandlePropertyDeclaration(Analyze);
     }
 }
-}

CliFx.Analyzers/ParameterMustHaveValidValidatorsAnalyzer.cs

@@ -5,15 +5,15 @@ using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 
-namespace CliFx.Analyzers
-{
+namespace CliFx.Analyzers;
+
 [DiagnosticAnalyzer(LanguageNames.CSharp)]
 public class ParameterMustHaveValidValidatorsAnalyzer : AnalyzerBase
 {
     public ParameterMustHaveValidValidatorsAnalyzer()
         : base(
             $"Parameter validators must derive from `{SymbolNames.CliFxBindingValidatorClass}`",
-                $"All validators specified for this parameter must derive from `{SymbolNames.CliFxBindingValidatorClass}`.")
+            $"Each validator specified for this parameter must derive from a compatible `{SymbolNames.CliFxBindingValidatorClass}`.")
     {
     }
 
@@ -28,14 +28,22 @@ namespace CliFx.Analyzers
 
         foreach (var validatorType in parameter.ValidatorTypes)
         {
-                // We check against an internal interface because checking against a generic class is a pain
-                var validatorImplementsInterface = validatorType
-                    .AllInterfaces
-                    .Any(s => s.DisplayNameMatches(SymbolNames.CliFxBindingValidatorInterface));
+            var validatorValueType = validatorType
+                .GetBaseTypes()
+                .FirstOrDefault(t => t.ConstructedFrom.DisplayNameMatches(SymbolNames.CliFxBindingValidatorClass))?
+                .TypeArguments
+                .FirstOrDefault();
 
-                if (!validatorImplementsInterface)
+            // Value passed to the validator must be assignable from the property type
+            var isCompatible =
+                validatorValueType is not null &&
+                context.Compilation.IsAssignable(property.Type, validatorValueType);
+
+            if (!isCompatible)
             {
-                    context.ReportDiagnostic(CreateDiagnostic(propertyDeclaration.GetLocation()));
+                context.ReportDiagnostic(
+                    CreateDiagnostic(propertyDeclaration.Identifier.GetLocation())
+                );
 
                 // No need to report multiple identical diagnostics on the same node
                 break;
@@ -49,4 +57,3 @@ namespace CliFx.Analyzers
         context.HandlePropertyDeclaration(Analyze);
     }
 }
-}

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

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,25 @@ 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 ITypeSymbol? TryGetEnumerableUnderlyingType(this ITypeSymbol type) => type
+        .AllInterfaces
+        .FirstOrDefault(i => i.ConstructedFrom.SpecialType == SpecialType.System_Collections_Generic_IEnumerable_T)?
+        .TypeArguments[0];
+
+    public static bool IsAssignable(this Compilation compilation, ITypeSymbol source, ITypeSymbol destination) =>
+        compilation.ClassifyConversion(source, destination).Exists;
+
     public static void HandleClassDeclaration(
         this AnalysisContext analysisContext,
         Action<SyntaxNodeAnalysisContext, ClassDeclarationSyntax, ITypeSymbol> analyze)
@@ -50,4 +71,3 @@ namespace CliFx.Analyzers.Utils.Extensions
         }, SyntaxKind.PropertyDeclaration);
     }
 }
-}

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

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>());
 }
-}

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();
 }
-}

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

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());
 }
-}

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

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

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

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
@@ -17,4 +17,3 @@ namespace CliFx.Benchmarks
             .WithOptions(ConfigOptions.DisableOptimizationsValidator)
     );
 }
-}

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.1" />
+    <PackageReference Include="BenchmarkDotNet" Version="0.13.1" />
     <PackageReference Include="clipr" Version="1.6.1" />
-    <PackageReference Include="Cocona" Version="1.5.0" />
-    <PackageReference Include="CommandLineParser" Version="2.8.0" />
-    <PackageReference Include="McMaster.Extensions.CommandLineUtils" Version="3.1.0" />
+    <PackageReference Include="Cocona" Version="2.0.3" />
+    <PackageReference Include="CommandLineParser" Version="2.9.1" />
+    <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>

CliFx.Demo/CliFx.Demo.csproj

@@ -2,17 +2,17 @@
 
   <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="Microsoft.Extensions.DependencyInjection" Version="6.0.0" />
     <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
   </ItemGroup>
 
   <ItemGroup>
     <ProjectReference Include="..\CliFx\CliFx.csproj" />
-    <ProjectReference Include="..\CliFx.Analyzers\CliFx.Analyzers.csproj" ReferenceOutputAssembly="false" OutputItemType="Analyzer" />
+    <ProjectReference Include="..\CliFx.Analyzers\CliFx.Analyzers.csproj" ReferenceOutputAssembly="false" OutputItemType="analyzer" />
   </ItemGroup>
 
 </Project>

CliFx.Demo/Commands/BookAddCommand.cs

@@ -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)
     );
 }
-}

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

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

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

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

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

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>());
 }
-}

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");
@@ -38,4 +38,3 @@ namespace CliFx.Demo.Domain
         StoreLibrary(updatedLibrary);
     }
 }
-}

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();
-    }
-}

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

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

@@ -2,12 +2,12 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net5.0</TargetFramework>
+    <TargetFramework>net6.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
     <ProjectReference Include="..\CliFx\CliFx.csproj" />
-    <ProjectReference Include="..\CliFx.Analyzers\CliFx.Analyzers.csproj" ReferenceOutputAssembly="false" OutputItemType="Analyzer" />
+    <ProjectReference Include="..\CliFx.Analyzers\CliFx.Analyzers.csproj" ReferenceOutputAssembly="false" OutputItemType="analyzer" />
   </ItemGroup>
 
 </Project>

CliFx.Tests.Dummy/Commands/ConsoleTestCommand.cs

@@ -3,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;
     }
 }
-}

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

CliFx.Tests.Dummy/Program.cs

@@ -1,8 +1,8 @@
-using System.Reflection;
+using System;
+using System.Reflection;
 using System.Threading.Tasks;
 
-namespace CliFx.Tests.Dummy
-{
+namespace CliFx.Tests.Dummy;
 // This dummy application is used in tests for scenarios
 // that require an external process to properly verify.
 
@@ -15,7 +15,14 @@ namespace CliFx.Tests.Dummy
 
 public static partial class Program
 {
-        public static async Task Main() =>
+    public static async Task Main()
+    {
+        // Make sure color codes are not produced because we rely on the output in tests
+        Environment.SetEnvironmentVariable(
+            "DOTNET_SYSTEM_CONSOLE_ALLOW_ANSI_COLOR_REDIRECTION",
+            "false"
+        );
+
         await new CliApplicationBuilder()
             .AddCommandsFromThisAssembly()
             .Build()

CliFx.Tests/ApplicationSpecs.cs

@@ -6,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");
     }
 }
-}

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");
     }
 }
-}

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,15 +9,16 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Basic.Reference.Assemblies" Version="1.1.2" />
-    <PackageReference Include="CliWrap" Version="3.3.2" />
-    <PackageReference Include="FluentAssertions" Version="5.10.3" />
-    <PackageReference Include="GitHubActionsTestLogger" Version="1.2.0" />
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="3.9.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.9.4" />
+    <PackageReference Include="Basic.Reference.Assemblies" Version="1.2.4" />
+    <PackageReference Include="CliWrap" Version="3.4.4" />
+    <PackageReference Include="FluentAssertions" Version="6.7.0" />
+    <PackageReference Include="GitHubActionsTestLogger" Version="2.0.0" PrivateAssets="all" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.2.0" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="6.0.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.2.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="xunit.runner.visualstudio" Version="2.4.5" PrivateAssets="all" />
+    <PackageReference Include="coverlet.collector" Version="3.1.2" PrivateAssets="all" />
   </ItemGroup>
 
   <ItemGroup>

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)
@@ -27,7 +31,8 @@ namespace CliFx.Tests
         var command = "Hello world" | Cli.Wrap("dotnet")
             .WithArguments(a => a
                 .Add(Dummy.Program.Location)
-                    .Add("console-test"));
+                .Add("console-test")
+            );
 
         // Act
         var result = await command.ExecuteBufferedAsync();
@@ -77,9 +82,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 +140,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");
     }
 }

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");
     }
 }

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)
@@ -28,7 +28,8 @@ namespace CliFx.Tests
         var command = Cli.Wrap("dotnet")
             .WithArguments(a => a
                 .Add(Dummy.Program.Location)
-                    .Add("[debug]")) | stdOutBuffer;
+                .Add("[debug]")
+            ) | stdOutBuffer;
 
         // Act
         try
@@ -57,7 +58,7 @@ namespace CliFx.Tests
         }
         catch (OperationCanceledException)
         {
-                // It's expected to fail
+            // This is expected
         }
 
         var stdOut = stdOutBuffer.ToString();
@@ -109,4 +110,3 @@ public class Command : ICommand
         );
     }
 }
-}

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)
@@ -246,9 +246,11 @@ public class Command : ICommand
         var command = Cli.Wrap("dotnet")
             .WithArguments(a => a
                 .Add(Dummy.Program.Location)
-                    .Add("env-test"))
+                .Add("env-test")
+            )
             .WithEnvironmentVariables(e => e
-                    .Set("ENV_TARGET", "Mars"));
+                .Set("ENV_TARGET", "Mars")
+            );
 
         // Act
         var result = await command.ExecuteBufferedAsync();
@@ -257,4 +259,3 @@ public class Command : ICommand
         result.StandardOutput.Trim().Should().Be("Hello Mars!");
     }
 }
-}

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");
     }
 }
-}

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()
     {
@@ -965,4 +1016,3 @@ public class SecondCommandSecondChildCommand : ICommand
         stdOut.Trim().Should().Be("v6.9");
     }
 }
-}

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");
     }
 }
-}

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)");
     }
 }
-}

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");
     }
 }
-}

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();
     }
 }
-}

CliFx.Tests/TypeActivationSpecs.cs

@@ -4,11 +4,12 @@ using System.Threading.Tasks;
 using CliFx.Infrastructure;
 using CliFx.Tests.Utils;
 using FluentAssertions;
+using Microsoft.Extensions.DependencyInjection;
 using Xunit;
 using Xunit.Abstractions;
 
-namespace CliFx.Tests
-{
+namespace CliFx.Tests;
+
 public class TypeActivationSpecs : SpecsBase
 {
     public TypeActivationSpecs(ITestOutputHelper testOutput)
@@ -87,7 +88,7 @@ public class Command : ICommand
     }
 
     [Fact]
-        public async Task Delegate_type_activator_can_initialize_a_type_using_a_custom_function()
+    public async Task Custom_type_activator_can_initialize_a_type_using_a_given_function()
     {
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
@@ -110,7 +111,7 @@ public class Command : ICommand
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
-                .UseTypeActivator(type => Activator.CreateInstance(type, "hello world")!)
+            .UseTypeActivator(type => Activator.CreateInstance(type, "Hello world")!)
             .Build();
 
         // Act
@@ -123,11 +124,55 @@ public class Command : ICommand
 
         // Assert
         exitCode.Should().Be(0);
-            stdOut.Trim().Should().Be("hello world");
+        stdOut.Trim().Should().Be("Hello world");
     }
 
     [Fact]
-        public async Task Delegate_type_activator_fails_if_the_underlying_function_returns_null()
+    public async Task Custom_type_activator_can_initialize_a_type_using_a_service_provider()
+    {
+        // Arrange
+        var commandType = DynamicCommandBuilder.Compile(
+            // language=cs
+            @"
+[Command]
+public class Command : ICommand
+{
+    private readonly string _foo;
+
+    public Command(string foo) => _foo = foo;
+
+    public ValueTask ExecuteAsync(IConsole console)
+    {
+        console.Output.WriteLine(_foo);
+        return default;
+    }
+}");
+
+        var serviceProvider = new ServiceCollection()
+            .AddSingleton(commandType, Activator.CreateInstance(commandType, "Hello world")!)
+            .BuildServiceProvider();
+
+        var application = new CliApplicationBuilder()
+            .AddCommand(commandType)
+            .UseConsole(FakeConsole)
+            .UseTypeActivator(serviceProvider)
+            .Build();
+
+        // Act
+        var exitCode = await application.RunAsync(
+            Array.Empty<string>(),
+            new Dictionary<string, string>()
+        );
+
+        var stdOut = FakeConsole.ReadOutputString();
+
+        // Assert
+        exitCode.Should().Be(0);
+        stdOut.Trim().Should().Be("Hello world");
+    }
+
+    [Fact]
+    public async Task Custom_type_activator_fails_if_the_underlying_function_returns_null()
     {
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
@@ -162,4 +207,3 @@ public class Command : ICommand
         stdErr.Should().Contain("Failed to create an instance of type");
     }
 }
-}

CliFx.Tests/Utils/DynamicCommandBuilder.cs

@@ -8,8 +8,8 @@ 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
@@ -106,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."
             );
         }
 
@@ -126,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();
     }
 }
-}

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

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());
     }
 }
-}