Update version

Closes #135

.github/ISSUE_TEMPLATE/config.yml

@@ -1,5 +1,8 @@
 blank_issues_enabled: false
 contact_links:
+  - name: ⚠ Feature request
+    url: https://github.com/Tyrrrz/.github/blob/master/docs/project-status.md
+    about: Sorry, but this project is in maintenance mode and no longer accepts new feature requests.
   - name: 💬 Discord server
     url: https://discord.gg/2SUWKFnHSm
     about: Chat with the project community.

.github/ISSUE_TEMPLATE/feature-request.yml

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

.github/workflows/main.yml

@@ -6,7 +6,7 @@ jobs:
   main:
     uses: Tyrrrz/.github/.github/workflows/nuget.yml@master
     with:
-      dotnet-version: 6.0.x
+      dotnet-version: 7.0.x
     secrets:
       CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
       NUGET_TOKEN: ${{ secrets.NUGET_TOKEN }}

Changelog.md

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

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

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net7.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
@@ -9,14 +9,14 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Basic.Reference.Assemblies" Version="1.2.4" />
+    <PackageReference Include="Basic.Reference.Assemblies.Net70" Version="1.4.1" />
-    <PackageReference Include="GitHubActionsTestLogger" Version="2.0.0" PrivateAssets="all" />
+    <PackageReference Include="GitHubActionsTestLogger" Version="2.0.2" PrivateAssets="all" />
-    <PackageReference Include="FluentAssertions" Version="6.7.0" />
+    <PackageReference Include="FluentAssertions" Version="6.11.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.2.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.5.0" />
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.2.0" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.5.0" />
-    <PackageReference Include="xunit" Version="2.4.1" />
+    <PackageReference Include="xunit" Version="2.4.2" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5" PrivateAssets="all" />
-    <PackageReference Include="coverlet.collector" Version="3.1.2" PrivateAssets="all" />
+    <PackageReference Include="coverlet.collector" Version="3.2.0" PrivateAssets="all" />
   </ItemGroup>
 
   <ItemGroup>

CliFx.Analyzers.Tests/CommandMustBeAnnotatedAnalyzerSpecs.cs

@@ -13,11 +13,13 @@ public class CommandMustBeAnnotatedAnalyzerSpecs
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-public class MyCommand : ICommand
+            """
-{
+            public class MyCommand : ICommand
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            {
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -28,12 +30,14 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public abstract class MyCommand : ICommand
+            [Command]
-{
+            public abstract class MyCommand : ICommand
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            {
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -44,11 +48,13 @@ public abstract class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-public abstract class MyCommand : ICommand
+            """
-{
+            public abstract class MyCommand : ICommand
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            {
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -59,11 +65,13 @@ public abstract class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-public class Foo
+            """
-{
+            public class Foo
-    public int Bar { get; set; } = 5;
+            {
-}";
+                public int Bar { get; set; } = 5;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);

CliFx.Analyzers.Tests/CommandMustImplementInterfaceAnalyzerSpecs.cs

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

CliFx.Analyzers.Tests/OptionMustBeInsideCommandAnalyzerSpecs.cs

@@ -13,12 +13,14 @@ public class OptionMustBeInsideCommandAnalyzerSpecs
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-public class MyClass
+            """
-{
+            public class MyClass
-    [CommandOption(""foo"")]
+            {
-    public string Foo { get; set; }
+                [CommandOption("foo")]
-}";
+                public string Foo { get; set; }
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -29,15 +31,17 @@ public class MyClass
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandOption(""foo"")]
+            {
-    public string Foo { get; set; }
+                [CommandOption("foo")]
+                public string Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -48,12 +52,14 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-public abstract class MyCommand
+            """
-{
+            public abstract class MyCommand
-    [CommandOption(""foo"")]
+            {
-    public string Foo { get; set; }
+                [CommandOption("foo")]
-}";
+                public string Foo { get; set; }
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -64,14 +70,16 @@ public abstract class MyCommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    public string Foo { get; set; }
+            {
+                public string Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);

CliFx.Analyzers.Tests/OptionMustBeRequiredIfPropertyRequiredAnalyzerSpecs.cs

@@ -0,0 +1,114 @@
+using CliFx.Analyzers.Tests.Utils;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Xunit;
+
+namespace CliFx.Analyzers.Tests;
+
+public class OptionMustBeRequiredIfPropertyRequiredAnalyzerSpecs
+{
+    private static DiagnosticAnalyzer Analyzer { get; } = new OptionMustBeRequiredIfPropertyRequiredAnalyzer();
+
+    [Fact]
+    public void Analyzer_reports_an_error_if_a_non_required_option_is_bound_to_a_required_property()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption('f', IsRequired = false)]
+                public required string Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().ProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_required_option_is_bound_to_a_required_property()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption('f', IsRequired = true)]
+                public required string Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_non_required_option_is_bound_to_a_non_required_property()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption('f', IsRequired = false)]
+                public string Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_if_a_required_option_is_bound_to_a_non_required_property()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption('f', IsRequired = true)]
+                public string Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+
+    [Fact]
+    public void Analyzer_does_not_report_an_error_on_a_property_that_is_not_an_option()
+    {
+        // Arrange
+        // language=cs
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public required string Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
+
+        // Act & assert
+        Analyzer.Should().NotProduceDiagnostics(code);
+    }
+}

CliFx.Analyzers.Tests/OptionMustHaveNameOrShortNameAnalyzerSpecs.cs

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

CliFx.Analyzers.Tests/OptionMustHaveUniqueNameAnalyzerSpecs.cs

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

CliFx.Analyzers.Tests/OptionMustHaveUniqueShortNameAnalyzerSpecs.cs

@@ -13,18 +13,20 @@ public class OptionMustHaveUniqueShortNameAnalyzerSpecs
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandOption('f')]
+            {
-    public string Foo { get; set; }
+                [CommandOption('f')]
-
+                public string Foo { get; set; }
-    [CommandOption('f')]
+            
-    public string Bar { get; set; }
+                [CommandOption('f')]
-
+                public string Bar { get; set; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -35,18 +37,20 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandOption('f')]
+            {
-    public string Foo { get; set; }
+                [CommandOption('f')]
-
+                public string Foo { get; set; }
-    [CommandOption('b')]
+            
-    public string Bar { get; set; }
+                [CommandOption('b')]
-
+                public string Bar { get; set; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -57,18 +61,20 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandOption('f')]
+            {
-    public string Foo { get; set; }
+                [CommandOption('f')]
-
+                public string Foo { get; set; }
-    [CommandOption('F')]
+            
-    public string Bar { get; set; }
+                [CommandOption('F')]
-
+                public string Bar { get; set; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -79,15 +85,17 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandOption(""foo"")]
+            {
-    public string Foo { get; set; }
+                [CommandOption("foo")]
-
+                public string Foo { get; set; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -98,14 +106,16 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    public string Foo { get; set; }
+            {
-
+                public string Foo { get; set; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);

CliFx.Analyzers.Tests/OptionMustHaveValidConverterAnalyzerSpecs.cs

@@ -13,20 +13,22 @@ public class OptionMustHaveValidConverterAnalyzerSpecs
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-public class MyConverter
+            """
-{
+            public class MyConverter
-    public string Convert(string rawValue) => rawValue;
+            {
-}
+                public string Convert(string rawValue) => rawValue;
-
+            }
-[Command]
+            
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandOption(""foo"", Converter = typeof(MyConverter))]
+            {
-    public string Foo { get; set; }
+                [CommandOption("foo", Converter = typeof(MyConverter))]
-
+                public string Foo { get; set; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -37,20 +39,22 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-public class MyConverter : BindingConverter<int>
+            """
-{
+            public class MyConverter : BindingConverter<int>
-    public override int Convert(string rawValue) => 42;
+            {
-}
+                public override int Convert(string rawValue) => 42;
-
+            }
-[Command]
+            
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandOption(""foo"", Converter = typeof(MyConverter))]
+            {
-    public string Foo { get; set; }
+                [CommandOption("foo", Converter = typeof(MyConverter))]
-
+                public string Foo { get; set; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -61,20 +65,22 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-public class MyConverter : BindingConverter<string>
+            """
-{
+            public class MyConverter : BindingConverter<string>
-    public override string Convert(string rawValue) => rawValue;
+            {
-}
+                public override string Convert(string rawValue) => rawValue;
-
+            }
-[Command]
+            
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandOption(""foo"", Converter = typeof(MyConverter))]
+            {
-    public string Foo { get; set; }
+                [CommandOption("foo", Converter = typeof(MyConverter))]
-
+                public string Foo { get; set; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -85,20 +91,22 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-public class MyConverter : BindingConverter<int>
+            """
-{
+            public class MyConverter : BindingConverter<int>
-    public override int Convert(string rawValue) => 42;
+            {
-}
+                public override int Convert(string rawValue) => 42;
-
+            }
-[Command]
+            
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandOption(""foo"", Converter = typeof(MyConverter))]
+            {
-    public int? Foo { get; set; }
+                [CommandOption("foo", Converter = typeof(MyConverter))]
-
+                public int? Foo { get; set; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -109,20 +117,22 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-public class MyConverter : BindingConverter<string>
+            """
-{
+            public class MyConverter : BindingConverter<string>
-    public override string Convert(string rawValue) => rawValue;
+            {
-}
+                public override string Convert(string rawValue) => rawValue;
-
+            }
-[Command]
+            
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandOption(""foo"", Converter = typeof(MyConverter))]
+            {
-    public IReadOnlyList<string> Foo { get; set; }
+                [CommandOption("foo", Converter = typeof(MyConverter))]
-
+                public IReadOnlyList<string> Foo { get; set; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -133,15 +143,17 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandOption(""foo"")]
+            {
-    public string Foo { get; set; }
+                [CommandOption("foo")]
-
+                public string Foo { get; set; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -152,14 +164,16 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    public string Foo { get; set; }
+            {
-
+                public string Foo { get; set; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);

CliFx.Analyzers.Tests/OptionMustHaveValidNameAnalyzerSpecs.cs

@@ -13,15 +13,17 @@ public class OptionMustHaveValidNameAnalyzerSpecs
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandOption(""f"")]
+            {
-    public string Foo { get; set; }
+                [CommandOption("f")]
-
+                public string Foo { get; set; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -32,15 +34,17 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandOption(""1foo"")]
+            {
-    public string Foo { get; set; }
+                [CommandOption("1foo")]
-
+                public string Foo { get; set; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -51,15 +55,17 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandOption(""foo"")]
+            {
-    public string Foo { get; set; }
+                [CommandOption("foo")]
-
+                public string Foo { get; set; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -70,15 +76,17 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandOption('f')]
+            {
-    public string Foo { get; set; }
+                [CommandOption('f')]
-
+                public string Foo { get; set; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -89,14 +97,16 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    public string Foo { get; set; }
+            {
-
+                public string Foo { get; set; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);

CliFx.Analyzers.Tests/OptionMustHaveValidShortNameAnalyzerSpecs.cs

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

CliFx.Analyzers.Tests/OptionMustHaveValidValidatorsAnalyzerSpecs.cs

@@ -13,20 +13,22 @@ public class OptionMustHaveValidValidatorsAnalyzerSpecs
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-public class MyValidator
+            """
-{
+            public class MyValidator
-    public void Validate(string value) {}
+            {
-}
+                public void Validate(string value) {}
-
+            }
-[Command]
+            
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandOption(""foo"", Validators = new[] {typeof(MyValidator)})]
+            {
-    public string Foo { get; set; }
+                [CommandOption("foo", Validators = new[] {typeof(MyValidator)})]
-
+                public string Foo { get; set; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -37,20 +39,22 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-public class MyValidator : BindingValidator<int>
+            """
-{
+            public class MyValidator : BindingValidator<int>
-    public override BindingValidationError Validate(int value) => Ok();
+            {
-}
+                public override BindingValidationError Validate(int value) => Ok();
-
+            }
-[Command]
+            
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandOption(""foo"", Validators = new[] {typeof(MyValidator)})]
+            {
-    public string Foo { get; set; }
+                [CommandOption("foo", Validators = new[] {typeof(MyValidator)})]
-
+                public string Foo { get; set; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -61,20 +65,22 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-public class MyValidator : BindingValidator<string>
+            """
-{
+            public class MyValidator : BindingValidator<string>
-    public override BindingValidationError Validate(string value) => Ok();
+            {
-}
+                public override BindingValidationError Validate(string value) => Ok();
-
+            }
-[Command]
+            
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandOption(""foo"", Validators = new[] {typeof(MyValidator)})]
+            {
-    public string Foo { get; set; }
+                [CommandOption("foo", Validators = new[] {typeof(MyValidator)})]
-
+                public string Foo { get; set; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -85,15 +91,17 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandOption(""foo"")]
+            {
-    public string Foo { get; set; }
+                [CommandOption("foo")]
-
+                public string Foo { get; set; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -104,14 +112,16 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    public string Foo { get; set; }
+            {
-
+                public string Foo { get; set; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);

CliFx.Analyzers.Tests/ParameterMustBeInsideCommandAnalyzerSpecs.cs

@@ -13,12 +13,14 @@ public class ParameterMustBeInsideCommandAnalyzerSpecs
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-public class MyClass
+            """
-{
+            public class MyClass
-    [CommandParameter(0)]
+            {
-    public string Foo { get; set; }
+                [CommandParameter(0)]
-}";
+                public string Foo { get; set; }
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -29,15 +31,17 @@ public class MyClass
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandParameter(0)]
+            {
-    public string Foo { get; set; }
+                [CommandParameter(0)]
-
+                public string Foo { get; set; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -48,12 +52,14 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-public abstract class MyCommand
+            """
-{
+            public abstract class MyCommand
-    [CommandParameter(0)]
+            {
-    public string Foo { get; set; }
+                [CommandParameter(0)]
-}";
+                public string Foo { get; set; }
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -64,14 +70,16 @@ public abstract class MyCommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    public string Foo { get; set; }
+            {
-
+                public string Foo { get; set; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);

CliFx.Analyzers.Tests/ParameterMustBeLastIfNonRequiredAnalyzerSpecs.cs

@@ -13,18 +13,20 @@ public class ParameterMustBeLastIfNonRequiredAnalyzerSpecs
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandParameter(0, Name = ""foo"", IsRequired = false)]
+            {
-    public string Foo { get; set; }
+                [CommandParameter(0, IsRequired = false)]
-
+                public string Foo { get; set; }
-    [CommandParameter(1, Name = ""bar"")]
+            
-    public string Bar { get; set; }
+                [CommandParameter(1)]
-
+                public string Bar { get; set; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -35,18 +37,20 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandParameter(0, Name = ""foo"")]
+            {
-    public string Foo { get; set; }
+                [CommandParameter(0)]
-
+                public string Foo { get; set; }
-    [CommandParameter(1, Name = ""bar"", IsRequired = false)]
+            
-    public string Bar { get; set; }
+                [CommandParameter(1, IsRequired = false)]
-
+                public string Bar { get; set; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -57,18 +61,20 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandParameter(0, Name = ""foo"")]
+            {
-    public string Foo { get; set; }
+                [CommandParameter(0)]
-
+                public string Foo { get; set; }
-    [CommandParameter(1, Name = ""bar"", IsRequired = true)]
+            
-    public string Bar { get; set; }
+                [CommandParameter(1, IsRequired = true)]
-
+                public string Bar { get; set; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -79,14 +85,16 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    public string Foo { get; set; }
+            {
-
+                public string Foo { get; set; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);

CliFx.Analyzers.Tests/ParameterMustBeLastIfNonScalarAnalyzerSpecs.cs

@@ -13,18 +13,20 @@ public class ParameterMustBeLastIfNonScalarAnalyzerSpecs
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandParameter(0)]
+            {
-    public string[] Foo { get; set; }
+                [CommandParameter(0)]
-
+                public string[] Foo { get; set; }
-    [CommandParameter(1)]
+            
-    public string Bar { get; set; }
+                [CommandParameter(1)]
-
+                public string Bar { get; set; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -35,18 +37,20 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandParameter(0)]
+            {
-    public string Foo { get; set; }
+                [CommandParameter(0)]
-
+                public string Foo { get; set; }
-    [CommandParameter(1)]
+            
-    public string[] Bar { get; set; }
+                [CommandParameter(1)]
-
+                public string[] Bar { get; set; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -57,18 +61,20 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandParameter(0)]
+            {
-    public string Foo { get; set; }
+                [CommandParameter(0)]
-
+                public string Foo { get; set; }
-    [CommandParameter(1)]
+            
-    public string Bar { get; set; }
+                [CommandParameter(1)]
-
+                public string Bar { get; set; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -79,14 +85,16 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    public string Foo { get; set; }
+            {
-
+                public string Foo { get; set; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);

CliFx.Analyzers.Tests/ParameterMustBeRequiredIfPropertyRequiredAnalyzerSpecs.cs

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

CliFx.Analyzers.Tests/ParameterMustBeSingleIfNonRequiredAnalyzerSpecs.cs

@@ -13,18 +13,20 @@ public class ParameterMustBeSingleIfNonRequiredAnalyzerSpecs
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandParameter(0, IsRequired = false)]
+            {
-    public string Foo { get; set; }
+                [CommandParameter(0, IsRequired = false)]
-
+                public string Foo { get; set; }
-    [CommandParameter(1, IsRequired = false)]
+            
-    public string Bar { get; set; }
+                [CommandParameter(1, IsRequired = false)]
-
+                public string Bar { get; set; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -35,18 +37,20 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandParameter(0)]
+            {
-    public string Foo { get; set; }
+                [CommandParameter(0)]
-
+                public string Foo { get; set; }
-    [CommandParameter(1, IsRequired = false)]
+            
-    public string Bar { get; set; }
+                [CommandParameter(1, IsRequired = false)]
-
+                public string Bar { get; set; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -57,18 +61,20 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandParameter(0)]
+            {
-    public string Foo { get; set; }
+                [CommandParameter(0)]
-
+                public string Foo { get; set; }
-    [CommandParameter(1, IsRequired = true)]
+            
-    public string Bar { get; set; }
+                [CommandParameter(1, IsRequired = true)]
-
+                public string Bar { get; set; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -79,14 +85,16 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    public string Foo { get; set; }
+            {
-
+                public string Foo { get; set; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);

CliFx.Analyzers.Tests/ParameterMustBeSingleIfNonScalarAnalyzerSpecs.cs

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

CliFx.Analyzers.Tests/ParameterMustHaveUniqueNameAnalyzerSpecs.cs

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

CliFx.Analyzers.Tests/ParameterMustHaveUniqueOrderAnalyzerSpecs.cs

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

CliFx.Analyzers.Tests/ParameterMustHaveValidConverterAnalyzerSpecs.cs

@@ -13,20 +13,22 @@ public class ParameterMustHaveValidConverterAnalyzerSpecs
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-public class MyConverter
+            """
-{
+            public class MyConverter
-    public string Convert(string rawValue) => rawValue;
+            {
-}
+                public string Convert(string rawValue) => rawValue;
-
+            }
-[Command]
+            
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandParameter(0, Converter = typeof(MyConverter))]
+            {
-    public string Foo { get; set; }
+                [CommandParameter(0, Converter = typeof(MyConverter))]
-
+                public string Foo { get; set; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -37,20 +39,22 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-public class MyConverter : BindingConverter<int>
+            """
-{
+            public class MyConverter : BindingConverter<int>
-    public override int Convert(string rawValue) => 42;
+            {
-}
+                public override int Convert(string rawValue) => 42;
-
+            }
-[Command]
+            
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandParameter(0, Converter = typeof(MyConverter))]
+            {
-    public string Foo { get; set; }
+                [CommandParameter(0, Converter = typeof(MyConverter))]
-
+                public string Foo { get; set; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
 
         // Act & assert
@@ -62,20 +66,22 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-public class MyConverter : BindingConverter<string>
+            """
-{
+            public class MyConverter : BindingConverter<string>
-    public override string Convert(string rawValue) => rawValue;
+            {
-}
+                public override string Convert(string rawValue) => rawValue;
-
+            }
-[Command]
+            
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandParameter(0, Converter = typeof(MyConverter))]
+            {
-    public string Foo { get; set; }
+                [CommandParameter(0, Converter = typeof(MyConverter))]
-
+                public string Foo { get; set; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -86,20 +92,22 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-public class MyConverter : BindingConverter<int>
+            """
-{
+            public class MyConverter : BindingConverter<int>
-    public override int Convert(string rawValue) => 42;
+            {
-}
+                public override int Convert(string rawValue) => 42;
-
+            }
-[Command]
+            
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandOption(""foo"", Converter = typeof(MyConverter))]
+            {
-    public int? Foo { get; set; }
+                [CommandOption("foo", Converter = typeof(MyConverter))]
-
+                public int? Foo { get; set; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -110,20 +118,22 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-public class MyConverter : BindingConverter<string>
+            """
-{
+            public class MyConverter : BindingConverter<string>
-    public override string Convert(string rawValue) => rawValue;
+            {
-}
+                public override string Convert(string rawValue) => rawValue;
-
+            }
-[Command]
+            
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandParameter(0, Converter = typeof(MyConverter))]
+            {
-    public IReadOnlyList<string> Foo { get; set; }
+                [CommandParameter(0, Converter = typeof(MyConverter))]
-
+                public IReadOnlyList<string> Foo { get; set; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -134,15 +144,17 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandParameter(0)]
+            {
-    public string Foo { get; set; }
+                [CommandParameter(0)]
-
+                public string Foo { get; set; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -153,14 +165,16 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    public string Foo { get; set; }
+            {
-
+                public string Foo { get; set; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);

CliFx.Analyzers.Tests/ParameterMustHaveValidValidatorsAnalyzerSpecs.cs

@@ -13,20 +13,22 @@ public class ParameterMustHaveValidValidatorsAnalyzerSpecs
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-public class MyValidator
+            """
-{
+            public class MyValidator
-    public void Validate(string value) {}
+            {
-}
+                public void Validate(string value) {}
-
+            }
-[Command]
+            
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandParameter(0, Validators = new[] {typeof(MyValidator)})]
+            {
-    public string Foo { get; set; }
+                [CommandParameter(0, Validators = new[] {typeof(MyValidator)})]
-
+                public string Foo { get; set; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -37,20 +39,22 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-public class MyValidator : BindingValidator<int>
+            """
-{
+            public class MyValidator : BindingValidator<int>
-    public override BindingValidationError Validate(int value) => Ok();
+            {
-}
+                public override BindingValidationError Validate(int value) => Ok();
-
+            }
-[Command]
+            
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandParameter(0, Validators = new[] {typeof(MyValidator)})]
+            {
-    public string Foo { get; set; }
+                [CommandParameter(0, Validators = new[] {typeof(MyValidator)})]
-
+                public string Foo { get; set; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -61,20 +65,22 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-public class MyValidator : BindingValidator<string>
+            """
-{
+            public class MyValidator : BindingValidator<string>
-    public override BindingValidationError Validate(string value) => Ok();
+            {
-}
+                public override BindingValidationError Validate(string value) => Ok();
-
+            }
-[Command]
+            
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandParameter(0, Validators = new[] {typeof(MyValidator)})]
+            {
-    public string Foo { get; set; }
+                [CommandParameter(0, Validators = new[] {typeof(MyValidator)})]
-
+                public string Foo { get; set; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -85,15 +91,17 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    [CommandParameter(0)]
+            {
-    public string Foo { get; set; }
+                [CommandParameter(0)]
-
+                public string Foo { get; set; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -104,14 +112,16 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
+        const string code =
-[Command]
+            """
-public class MyCommand : ICommand
+            [Command]
-{
+            public class MyCommand : ICommand
-    public string Foo { get; set; }
+            {
-
+                public string Foo { get; set; }
-    public ValueTask ExecuteAsync(IConsole console) => default;
+            
-}";
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);

CliFx.Analyzers.Tests/SystemConsoleShouldBeAvoidedAnalyzerSpecs.cs

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

CliFx.Analyzers.Tests/Utils/AnalyzerAssertions.cs

@@ -58,7 +58,7 @@ internal class AnalyzerAssertions : ReferenceTypeAssertions<DiagnosticAnalyzer,
         var compilation = CSharpCompilation.Create(
             "CliFxTests_DynamicAssembly_" + Guid.NewGuid(),
             new[] { ast },
-            ReferenceAssemblies.Net50
+            Net70.References.All
                 .Append(MetadataReference.CreateFromFile(typeof(ICommand).Assembly.Location)),
             // DLL to avoid having to define the Main() method
             new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary)
@@ -72,9 +72,10 @@ internal class AnalyzerAssertions : ReferenceTypeAssertions<DiagnosticAnalyzer,
         if (compilationErrors.Any())
         {
             throw new InvalidOperationException(
-                "Failed to compile code." +
+                $"""
-                Environment.NewLine +
+                Failed to compile code.
-                string.Join(Environment.NewLine, compilationErrors.Select(e => e.ToString()))
+                {string.Join(Environment.NewLine, compilationErrors.Select(e => e.ToString()))}
+                """
             );
         }
 

CliFx.Analyzers/CliFx.Analyzers.csproj

@@ -3,14 +3,24 @@
   <PropertyGroup>
     <TargetFramework>netstandard2.0</TargetFramework>
     <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
-    <Nullable>annotations</Nullable>
+    <GenerateDependencyFile>true</GenerateDependencyFile>
+    <EnforceExtendedAnalyzerRules>true</EnforceExtendedAnalyzerRules>
     <NoWarn>$(NoWarn);RS1025;RS1026</NoWarn>
   </PropertyGroup>
 
+  <PropertyGroup>
+    <!--
+      Because this project only has a single target framework, the condition in
+      Directory.Build.props does not appear to work. This is a workaround for that.
+    -->
+    <Nullable>annotations</Nullable>
+  </PropertyGroup>
+
   <ItemGroup>
-    <!-- Keep this dependency as low as possible since we can't bundle it -->
+    <!-- Make sure to target the lowest possible version of the compiler for wider support -->
-    <!-- https://github.com/Tyrrrz/CliFx/issues/127 -->
+    <PackageReference Include="Microsoft.CodeAnalysis" Version="3.0.0" PrivateAssets="all" />
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="3.8.0" PrivateAssets="all" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="3.0.0" PrivateAssets="all" />
+    <PackageReference Include="PolyShim" Version="1.2.0" PrivateAssets="all" />
   </ItemGroup>
 
 </Project>

CliFx.Analyzers/ObjectModel/CommandOptionSymbol.cs

@@ -13,6 +13,8 @@ internal partial class CommandOptionSymbol : ICommandMemberSymbol
 
     public char? ShortName { get; }
 
+    public bool? IsRequired { get; }
+
     public ITypeSymbol? ConverterType { get; }
 
     public IReadOnlyList<ITypeSymbol> ValidatorTypes { get; }
@@ -21,12 +23,14 @@ internal partial class CommandOptionSymbol : ICommandMemberSymbol
         IPropertySymbol property,
         string? name,
         char? shortName,
+        bool? isRequired,
         ITypeSymbol? converterType,
         IReadOnlyList<ITypeSymbol> validatorTypes)
     {
         Property = property;
         Name = name;
         ShortName = shortName;
+        IsRequired = isRequired;
         ConverterType = converterType;
         ValidatorTypes = validatorTypes;
     }
@@ -56,6 +60,12 @@ internal partial class CommandOptionSymbol
             .Select(a => a.Value)
             .FirstOrDefault() as char?;
 
+        var isRequired = attribute
+            .NamedArguments
+            .Where(a => a.Key == "IsRequired")
+            .Select(a => a.Value.Value)
+            .FirstOrDefault() as bool?;
+
         var converter = attribute
             .NamedArguments
             .Where(a => a.Key == "Converter")
@@ -71,7 +81,7 @@ internal partial class CommandOptionSymbol
             .Cast<ITypeSymbol>()
             .ToArray();
 
-        return new CommandOptionSymbol(property, name, shortName, converter, validators);
+        return new CommandOptionSymbol(property, name, shortName, isRequired, converter, validators);
     }
 
     public static bool IsOptionProperty(IPropertySymbol property) =>

CliFx.Analyzers/OptionMustBeRequiredIfPropertyRequiredAnalyzer.cs

@@ -0,0 +1,49 @@
+using CliFx.Analyzers.ObjectModel;
+using CliFx.Analyzers.Utils.Extensions;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace CliFx.Analyzers;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public class OptionMustBeRequiredIfPropertyRequiredAnalyzer : AnalyzerBase
+{
+    public OptionMustBeRequiredIfPropertyRequiredAnalyzer()
+        : base(
+            "Options bound to required properties cannot be marked as non-required",
+            "This option cannot be marked as non-required because it's bound to a required property.")
+    {
+    }
+
+    private void Analyze(
+        SyntaxNodeAnalysisContext context,
+        PropertyDeclarationSyntax propertyDeclaration,
+        IPropertySymbol property)
+    {
+        if (property.ContainingType is null)
+            return;
+
+        if (!property.IsRequired())
+            return;
+
+        var option = CommandOptionSymbol.TryResolve(property);
+        if (option is null)
+            return;
+
+        if (option.IsRequired != false)
+            return;
+
+        context.ReportDiagnostic(
+            CreateDiagnostic(
+                propertyDeclaration.Identifier.GetLocation()
+            )
+        );
+    }
+
+    public override void Initialize(AnalysisContext context)
+    {
+        base.Initialize(context);
+        context.HandlePropertyDeclaration(Analyze);
+    }
+}

CliFx.Analyzers/OptionMustHaveUniqueNameAnalyzer.cs

@@ -39,7 +39,7 @@ public class OptionMustHaveUniqueNameAnalyzer : AnalyzerBase
             .ContainingType
             .GetMembers()
             .OfType<IPropertySymbol>()
-            .Where(m => !m.Equals(property, SymbolEqualityComparer.Default))
+            .Where(m => !m.Equals(property))
             .ToArray();
 
         foreach (var otherProperty in otherProperties)

CliFx.Analyzers/OptionMustHaveUniqueShortNameAnalyzer.cs

@@ -38,7 +38,7 @@ public class OptionMustHaveUniqueShortNameAnalyzer : AnalyzerBase
             .ContainingType
             .GetMembers()
             .OfType<IPropertySymbol>()
-            .Where(m => !m.Equals(property, SymbolEqualityComparer.Default))
+            .Where(m => !m.Equals(property))
             .ToArray();
 
         foreach (var otherProperty in otherProperties)

CliFx.Analyzers/ParameterMustBeLastIfNonRequiredAnalyzer.cs

@@ -37,7 +37,7 @@ public class ParameterMustBeLastIfNonRequiredAnalyzer : AnalyzerBase
             .ContainingType
             .GetMembers()
             .OfType<IPropertySymbol>()
-            .Where(m => !m.Equals(property, SymbolEqualityComparer.Default))
+            .Where(m => !m.Equals(property))
             .ToArray();
 
         foreach (var otherProperty in otherProperties)

CliFx.Analyzers/ParameterMustBeLastIfNonScalarAnalyzer.cs

@@ -37,7 +37,7 @@ public class ParameterMustBeLastIfNonScalarAnalyzer : AnalyzerBase
             .ContainingType
             .GetMembers()
             .OfType<IPropertySymbol>()
-            .Where(m => !m.Equals(property, SymbolEqualityComparer.Default))
+            .Where(m => !m.Equals(property))
             .ToArray();
 
         foreach (var otherProperty in otherProperties)

CliFx.Analyzers/ParameterMustBeRequiredIfPropertyRequiredAnalyzer.cs

@@ -0,0 +1,49 @@
+using CliFx.Analyzers.ObjectModel;
+using CliFx.Analyzers.Utils.Extensions;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace CliFx.Analyzers;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public class ParameterMustBeRequiredIfPropertyRequiredAnalyzer : AnalyzerBase
+{
+    public ParameterMustBeRequiredIfPropertyRequiredAnalyzer()
+        : base(
+            "Parameters bound to required properties cannot be marked as non-required",
+            "This parameter cannot be marked as non-required because it's bound to a required property.")
+    {
+    }
+
+    private void Analyze(
+        SyntaxNodeAnalysisContext context,
+        PropertyDeclarationSyntax propertyDeclaration,
+        IPropertySymbol property)
+    {
+        if (property.ContainingType is null)
+            return;
+
+        if (!property.IsRequired())
+            return;
+
+        var parameter = CommandParameterSymbol.TryResolve(property);
+        if (parameter is null)
+            return;
+
+        if (parameter.IsRequired != false)
+            return;
+
+        context.ReportDiagnostic(
+            CreateDiagnostic(
+                propertyDeclaration.Identifier.GetLocation()
+            )
+        );
+    }
+
+    public override void Initialize(AnalysisContext context)
+    {
+        base.Initialize(context);
+        context.HandlePropertyDeclaration(Analyze);
+    }
+}

CliFx.Analyzers/ParameterMustBeSingleIfNonRequiredAnalyzer.cs

@@ -37,7 +37,7 @@ public class ParameterMustBeSingleIfNonRequiredAnalyzer : AnalyzerBase
             .ContainingType
             .GetMembers()
             .OfType<IPropertySymbol>()
-            .Where(m => !m.Equals(property, SymbolEqualityComparer.Default))
+            .Where(m => !m.Equals(property))
             .ToArray();
 
         foreach (var otherProperty in otherProperties)

CliFx.Analyzers/ParameterMustBeSingleIfNonScalarAnalyzer.cs

@@ -37,7 +37,7 @@ public class ParameterMustBeSingleIfNonScalarAnalyzer : AnalyzerBase
             .ContainingType
             .GetMembers()
             .OfType<IPropertySymbol>()
-            .Where(m => !m.Equals(property, SymbolEqualityComparer.Default))
+            .Where(m => !m.Equals(property))
             .ToArray();
 
         foreach (var otherProperty in otherProperties)

CliFx.Analyzers/ParameterMustHaveUniqueNameAnalyzer.cs

@@ -39,7 +39,7 @@ public class ParameterMustHaveUniqueNameAnalyzer : AnalyzerBase
             .ContainingType
             .GetMembers()
             .OfType<IPropertySymbol>()
-            .Where(m => !m.Equals(property, SymbolEqualityComparer.Default))
+            .Where(m => !m.Equals(property))
             .ToArray();
 
         foreach (var otherProperty in otherProperties)

CliFx.Analyzers/ParameterMustHaveUniqueOrderAnalyzer.cs

@@ -35,7 +35,7 @@ public class ParameterMustHaveUniqueOrderAnalyzer : AnalyzerBase
             .ContainingType
             .GetMembers()
             .OfType<IPropertySymbol>()
-            .Where(m => !m.Equals(property, SymbolEqualityComparer.Default))
+            .Where(m => !m.Equals(property))
             .ToArray();
 
         foreach (var otherProperty in otherProperties)

CliFx.Analyzers/Utils/Extensions/RoslynExtensions.cs

@@ -34,6 +34,17 @@ internal static class RoslynExtensions
         .FirstOrDefault(i => i.ConstructedFrom.SpecialType == SpecialType.System_Collections_Generic_IEnumerable_T)?
         .TypeArguments[0];
 
+    // Detect if the property is required through roundabout means so as to not have to take dependency
+    // on higher versions of the C# compiler.
+    public static bool IsRequired(this IPropertySymbol property) => property
+        // Can't rely on the RequiredMemberAttribute because it's generated by the compiler, not added by the user,
+        // so we have to check for the presence of the `required` modifier in the syntax tree instead.
+        .DeclaringSyntaxReferences
+        .Select(r => r.GetSyntax())
+        .OfType<PropertyDeclarationSyntax>()
+        .SelectMany(p => p.Modifiers)
+        .Any(m => m.IsKind((SyntaxKind)8447));
+
     public static bool IsAssignable(this Compilation compilation, ITypeSymbol source, ITypeSymbol destination) =>
         compilation.ClassifyConversion(source, destination).Exists;
 

CliFx.Analyzers/Utils/Extensions/StringExtensions.cs

@@ -10,7 +10,7 @@ internal static class StringExtensions
         StringComparison comparison = StringComparison.Ordinal)
     {
         while (str.EndsWith(sub, comparison))
-            str = str.Substring(0, str.Length - sub.Length);
+            str = str[..^sub.Length];
 
         return str;
     }

CliFx.Benchmarks/CliFx.Benchmarks.csproj

@@ -2,16 +2,16 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net7.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="BenchmarkDotNet" Version="0.13.1" />
+    <PackageReference Include="BenchmarkDotNet" Version="0.13.5" />
     <PackageReference Include="clipr" Version="1.6.1" />
-    <PackageReference Include="Cocona" Version="2.0.3" />
+    <PackageReference Include="Cocona" Version="2.2.0" />
     <PackageReference Include="CommandLineParser" Version="2.9.1" />
-    <PackageReference Include="McMaster.Extensions.CommandLineUtils" Version="4.0.1" />
+    <PackageReference Include="McMaster.Extensions.CommandLineUtils" Version="4.0.2" />
-    <PackageReference Include="PowerArgs" Version="3.6.0" />
+    <PackageReference Include="PowerArgs" Version="4.0.2" />
     <PackageReference Include="System.CommandLine" Version="2.0.0-beta1.20574.7" />
   </ItemGroup>
 

CliFx.Demo/CliFx.Demo.csproj

@@ -2,12 +2,11 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net7.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="6.0.0" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="7.0.0" />
-    <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
   </ItemGroup>
 
   <ItemGroup>

CliFx.Demo/Commands/BookAddCommand.cs

@@ -14,10 +14,10 @@ public partial class BookAddCommand : ICommand
     private readonly LibraryProvider _libraryProvider;
 
     [CommandParameter(0, Name = "title", Description = "Book title.")]
-    public string Title { get; init; } = "";
+    public required string Title { get; init; }
 
     [CommandOption("author", 'a', IsRequired = true, Description = "Book author.")]
-    public string Author { get; init; } = "";
+    public required string Author { get; init; }
 
     [CommandOption("published", 'p', Description = "Book publish date.")]
     public DateTimeOffset Published { get; init; } = CreateRandomDate();

CliFx.Demo/Commands/BookCommand.cs

@@ -13,7 +13,7 @@ public class BookCommand : ICommand
     private readonly LibraryProvider _libraryProvider;
 
     [CommandParameter(0, Name = "title", Description = "Title of the book to retrieve.")]
-    public string Title { get; init; } = "";
+    public required string Title { get; init; }
 
     public BookCommand(LibraryProvider libraryProvider)
     {

CliFx.Demo/Commands/BookRemoveCommand.cs

@@ -12,7 +12,7 @@ public class BookRemoveCommand : ICommand
     private readonly LibraryProvider _libraryProvider;
 
     [CommandParameter(0, Name = "title", Description = "Title of the book to remove.")]
-    public string Title { get; init; } = "";
+    public required string Title { get; init; }
 
     public BookRemoveCommand(LibraryProvider libraryProvider)
     {

CliFx.Demo/Domain/Book.cs

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

CliFx.Demo/Domain/Isbn.cs

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

CliFx.Demo/Domain/Library.cs

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

CliFx.Demo/Domain/LibraryProvider.cs

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

CliFx.Demo/Readme.md

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

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

@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net7.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>

CliFx.Tests.Dummy/Program.cs

@@ -3,12 +3,13 @@ using System.Reflection;
 using System.Threading.Tasks;
 
 namespace CliFx.Tests.Dummy;
+
 // This dummy application is used in tests for scenarios
 // that require an external process to properly verify.
 
 public static partial class Program
 {
-    public static Assembly Assembly { get; } = typeof(Program).Assembly;
+    public static Assembly Assembly { get; } = Assembly.GetExecutingAssembly();
 
     public static string Location { get; } = Assembly.Location;
 }

CliFx.Tests/CancellationSpecs.cs

@@ -16,33 +16,35 @@ public class CancellationSpecs : SpecsBase
     }
 
     [Fact]
-    public async Task Command_can_register_to_receive_a_cancellation_signal_from_the_console()
+    public async Task Command_can_receive_a_cancellation_signal_from_the_console()
     {
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    public async ValueTask ExecuteAsync(IConsole console)
+                public async ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        try
+                    try
-        {
+                    {
-            await Task.Delay(
+                        await Task.Delay(
-                TimeSpan.FromSeconds(3),
+                            TimeSpan.FromSeconds(3),
-                console.RegisterCancellationHandler()
+                            console.RegisterCancellationHandler()
-            );
+                        );
 
-            console.Output.WriteLine(""Completed successfully"");
+                        console.Output.WriteLine("Completed successfully");
-        }
+                    }
-        catch (OperationCanceledException)
+                    catch (OperationCanceledException)
-        {
+                    {
-            console.Output.WriteLine(""Cancelled"");
+                        console.Output.WriteLine("Cancelled");
-            throw;
+                        throw;
-        }
+                    }
-    }
+                }
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)

CliFx.Tests/CliFx.Tests.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net6.0</TargetFramework>
+    <TargetFramework>net7.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
@@ -9,16 +9,16 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Basic.Reference.Assemblies" Version="1.2.4" />
+    <PackageReference Include="Basic.Reference.Assemblies.Net70" Version="1.4.1" />
-    <PackageReference Include="CliWrap" Version="3.4.4" />
+    <PackageReference Include="CliWrap" Version="3.6.1" />
-    <PackageReference Include="FluentAssertions" Version="6.7.0" />
+    <PackageReference Include="FluentAssertions" Version="6.11.0" />
-    <PackageReference Include="GitHubActionsTestLogger" Version="2.0.0" PrivateAssets="all" />
+    <PackageReference Include="GitHubActionsTestLogger" Version="2.0.2" PrivateAssets="all" />
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.2.0" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.5.0" />
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="6.0.0" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="7.0.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.2.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.5.0" />
-    <PackageReference Include="xunit" Version="2.4.1" />
+    <PackageReference Include="xunit" Version="2.4.2" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5" PrivateAssets="all" />
-    <PackageReference Include="coverlet.collector" Version="3.1.2" PrivateAssets="all" />
+    <PackageReference Include="coverlet.collector" Version="3.2.0" PrivateAssets="all" />
   </ItemGroup>
 
   <ItemGroup>
@@ -26,12 +26,4 @@
     <ProjectReference Include="..\CliFx\CliFx.csproj" />
   </ItemGroup>
 
-  <ItemGroup>
-    <None Include="../CliFx.Tests.Dummy/bin/$(Configuration)/$(TargetFramework)/CliFx.Tests.Dummy.runtimeconfig.json">
-      <Link>CliFx.Tests.Dummy.runtimeconfig.json</Link>
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-      <Visible>false</Visible>
-    </None>
-  </ItemGroup>
-
 </Project>

CliFx.Tests/ConsoleSpecs.cs

@@ -21,7 +21,7 @@ public class ConsoleSpecs : SpecsBase
     {
     }
 
-    [Fact]
+    [Fact(Timeout = 15000)]
     public async Task Real_console_maps_directly_to_system_console()
     {
         // Can't verify our own console output, so using an
@@ -48,27 +48,28 @@ public class ConsoleSpecs : SpecsBase
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{   
+            {
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        console.ResetColor();
+                    console.ResetColor();
-        console.ForegroundColor = ConsoleColor.DarkMagenta;
+                    console.ForegroundColor = ConsoleColor.DarkMagenta;
-        console.BackgroundColor = ConsoleColor.DarkMagenta;
+                    console.BackgroundColor = ConsoleColor.DarkMagenta;
-        console.WindowWidth = 100;
+                    console.WindowWidth = 100;
-        console.WindowHeight = 25;
+                    console.WindowHeight = 25;
-        console.CursorLeft = 42;
+                    console.CursorLeft = 42;
-        console.CursorTop = 24;
+                    console.CursorTop = 24;
 
-        console.Output.WriteLine(""Hello "");
+                    console.Output.WriteLine("Hello ");
-        console.Error.WriteLine(""world!"");
+                    console.Error.WriteLine("world!");
 
-        return default;
+                    return default;
-    }
+                }
-}
+            }
-");
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -108,20 +109,21 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{   
+            {
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        var input = console.Input.ReadToEnd();
+                    var input = console.Input.ReadToEnd();
-        console.Output.WriteLine(input);
+                    console.Output.WriteLine(input);
-        console.Error.WriteLine(input);
+                    console.Error.WriteLine(input);
 
-        return default;
+                    return default;
-    }
+                }
-}
+            }
-");
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -151,20 +153,21 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{   
+            {
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        console.Output.WriteLine(console.ReadKey().Key);
+                    console.Output.WriteLine(console.ReadKey().Key);
-        console.Output.WriteLine(console.ReadKey().Key);
+                    console.Output.WriteLine(console.ReadKey().Key);
-        console.Output.WriteLine(console.ReadKey().Key);
+                    console.Output.WriteLine(console.ReadKey().Key);
 
-        return default;
+                    return default;
-    }
+                }
-}
+            }
-");
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)

CliFx.Tests/ConversionSpecs.cs

@@ -21,20 +21,22 @@ public class ConversionSpecs : SpecsBase
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandOption('f')]
+                [CommandOption('f')]
-    public string Foo { get; set; }
+                public string Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine(Foo);
+                    return default;
+                }
+            }
+            """
+        );
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(Foo);
-        return default;
-    }
-}
-");
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -59,20 +61,22 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandOption('f')]
+                [CommandOption('f')]
-    public object Foo { get; set; }
+                public object Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine(Foo);
+                    return default;
+                }
+            }
+            """
+        );
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(Foo);
-        return default;
-    }
-}
-");
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -97,25 +101,27 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandOption('f')]
+                [CommandOption('f')]
-    public bool Foo { get; set; }
+                public bool Foo { get; set; }
 
-    [CommandOption('b')]
+                [CommandOption('b')]
-    public bool Bar { get; set; }
+                public bool Bar { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        console.Output.WriteLine(""Foo = "" + Foo);
+                    console.Output.WriteLine("Foo = " + Foo);
-        console.Output.WriteLine(""Bar = "" + Bar);
+                    console.Output.WriteLine("Bar = " + Bar);
+
+                    return default;
+                }
+            }
+            """
+        );
 
-        return default;
-    }
-}
-");
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -143,20 +149,22 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandOption('f')]
+                [CommandOption('f')]
-    public bool Foo { get; set; }
+                public bool Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine(Foo);
+                    return default;
+                }
+            }
+            """
+        );
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(Foo);
-        return default;
-    }
-}
-");
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -181,20 +189,22 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandOption('f')]
+                [CommandOption('f')]
-    public int Foo { get; set; }
+                public int Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine(Foo);
+                    return default;
+                }
+            }
+            """
+        );
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(Foo);
-        return default;
-    }
-}
-");
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -219,20 +229,22 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandOption('f')]
+                [CommandOption('f')]
-    public double Foo { get; set; }
+                public double Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine(Foo.ToString(CultureInfo.InvariantCulture));
+                    return default;
+                }
+            }
+            """
+        );
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(Foo.ToString(CultureInfo.InvariantCulture));
-        return default;
-    }
-}
-");
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -257,20 +269,22 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandOption('f')]
+                [CommandOption('f')]
-    public DateTimeOffset Foo { get; set; }
+                public DateTimeOffset Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine(Foo.ToString("u", CultureInfo.InvariantCulture));
+                    return default;
+                }
+            }
+            """
+        );
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(Foo.ToString(""u"", CultureInfo.InvariantCulture));
-        return default;
-    }
-}
-");
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -295,20 +309,22 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandOption('f')]
+                [CommandOption('f')]
-    public TimeSpan Foo { get; set; }
+                public TimeSpan Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine(Foo.ToString(null, CultureInfo.InvariantCulture));
+                    return default;
+                }
+            }
+            """
+        );
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(Foo.ToString(null, CultureInfo.InvariantCulture));
-        return default;
-    }
-}
-");
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -333,22 +349,24 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-public enum CustomEnum { One = 1, Two = 2, Three = 3 }
+            public enum CustomEnum { One = 1, Two = 2, Three = 3 }
 
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandOption('f')]
+                [CommandOption('f')]
-    public CustomEnum Foo { get; set; }
+                public CustomEnum Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine((int) Foo);
+                    return default;
+                }
+            }
+            """
+        );
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine((int) Foo);
-        return default;
-    }
-}
-");
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -373,25 +391,27 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandOption('f')]
+                [CommandOption('f')]
-    public int? Foo { get; set; }
+                public int? Foo { get; set; }
 
-    [CommandOption('b')]
+                [CommandOption('b')]
-    public int? Bar { get; set; }
+                public int? Bar { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        console.Output.WriteLine(""Foo = "" + Foo);
+                    console.Output.WriteLine("Foo = " + Foo);
-        console.Output.WriteLine(""Bar = "" + Bar);
+                    console.Output.WriteLine("Bar = " + Bar);
+
+                    return default;
+                }
+            }
+            """
+        );
 
-        return default;
-    }
-}
-");
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -419,27 +439,29 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-public enum CustomEnum { One = 1, Two = 2, Three = 3 }
+            public enum CustomEnum { One = 1, Two = 2, Three = 3 }
 
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandOption('f')]
+                [CommandOption('f')]
-    public CustomEnum? Foo { get; set; }
+                public CustomEnum? Foo { get; set; }
 
-    [CommandOption('b')]
+                [CommandOption('b')]
-    public CustomEnum? Bar { get; set; }
+                public CustomEnum? Bar { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        console.Output.WriteLine(""Foo = "" + (int?) Foo);
+                    console.Output.WriteLine("Foo = " + (int?) Foo);
-        console.Output.WriteLine(""Bar = "" + (int?) Bar);
+                    console.Output.WriteLine("Bar = " + (int?) Bar);
+
+                    return default;
+                }
+            }
+            """
+        );
 
-        return default;
-    }
-}
-");
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -467,27 +489,29 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-public class CustomType
+            public class CustomType
-{
+            {
-    public string Value { get; }
+                public string Value { get; }
 
-    public CustomType(string value) => Value = value;
+                public CustomType(string value) => Value = value;
-}
+            }
 
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandOption('f')]
+                [CommandOption('f')]
-    public CustomType Foo { get; set; }
+                public CustomType Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine(Foo.Value);
+                    return default;
+                }
+            }
+            """
+        );
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(Foo.Value);
-        return default;
-    }
-}
-");
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -512,45 +536,47 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-public class CustomTypeA
+            public class CustomTypeA
-{
+            {
-    public string Value { get; }
+                public string Value { get; }
 
-    private CustomTypeA(string value) => Value = value;
+                private CustomTypeA(string value) => Value = value;
 
-    public static CustomTypeA Parse(string value) => 
+                public static CustomTypeA Parse(string value) =>
-        new CustomTypeA(value);
+                    new CustomTypeA(value);
-}
+            }
 
-public class CustomTypeB
+            public class CustomTypeB
-{
+            {
-    public string Value { get; }
+                public string Value { get; }
 
-    private CustomTypeB(string value) => Value = value;
+                private CustomTypeB(string value) => Value = value;
 
-    public static CustomTypeB Parse(string value, IFormatProvider formatProvider) =>
+                public static CustomTypeB Parse(string value, IFormatProvider formatProvider) =>
-        new CustomTypeB(value);
+                    new CustomTypeB(value);
-}
+            }
 
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandOption('f')]
+                [CommandOption('f')]
-    public CustomTypeA Foo { get; set; }
+                public CustomTypeA Foo { get; set; }
 
-    [CommandOption('b')]
+                [CommandOption('b')]
-    public CustomTypeB Bar { get; set; }
+                public CustomTypeB Bar { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        console.Output.WriteLine(""Foo = "" + Foo.Value);
+                    console.Output.WriteLine("Foo = " + Foo.Value);
-        console.Output.WriteLine(""Bar = "" + Bar.Value);
+                    console.Output.WriteLine("Bar = " + Bar.Value);
+
+                    return default;
+                }
+            }
+            """
+        );
 
-        return default;
-    }
-}
-");
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -578,26 +604,28 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-public class CustomConverter : BindingConverter<int>
+            public class CustomConverter : BindingConverter<int>
-{
+            {
-    public override int Convert(string rawValue) =>
+                public override int Convert(string rawValue) =>
-        rawValue.Length;
+                    rawValue.Length;
-}
+            }
 
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandOption('f', Converter = typeof(CustomConverter))]
+                [CommandOption('f', Converter = typeof(CustomConverter))]
-    public int Foo { get; set; }
+                public int Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine(Foo);
+                    return default;
+                }
+            }
+            """
+        );
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(Foo);
-        return default;
-    }
-}
-");
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -622,22 +650,24 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandOption('f')]
+                [CommandOption('f')]
-    public string[] Foo { get; set; }
+                public string[] Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        foreach (var i in Foo)
+                    foreach (var i in Foo)
-            console.Output.WriteLine(i);
+                        console.Output.WriteLine(i);
+
+                    return default;
+                }
+            }
+            """
+        );
 
-        return default;
-    }
-}
-");
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -666,22 +696,24 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandOption('f')]
+                [CommandOption('f')]
-    public IReadOnlyList<string> Foo { get; set; }
+                public IReadOnlyList<string> Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        foreach (var i in Foo)
+                    foreach (var i in Foo)
-            console.Output.WriteLine(i);
+                        console.Output.WriteLine(i);
+
+                    return default;
+                }
+            }
+            """
+        );
 
-        return default;
-    }
-}
-");
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -710,22 +742,24 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandOption('f')]
+                [CommandOption('f')]
-    public List<string> Foo { get; set; }
+                public List<string> Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        foreach (var i in Foo)
+                    foreach (var i in Foo)
-            console.Output.WriteLine(i);
+                        console.Output.WriteLine(i);
+
+                    return default;
+                }
+            }
+            """
+        );
 
-        return default;
-    }
-}
-");
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -754,22 +788,24 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandOption('f')]
+                [CommandOption('f')]
-    public int[] Foo { get; set; }
+                public int[] Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        foreach (var i in Foo)
+                    foreach (var i in Foo)
-            console.Output.WriteLine(i);
+                        console.Output.WriteLine(i);
+
+                    return default;
+                }
+            }
+            """
+        );
 
-        return default;
-    }
-}
-");
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -798,16 +834,18 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandOption('f')]
+                [CommandOption('f')]
-    public int Foo { get; set; }
+                public int Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """
+        );
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -832,18 +870,20 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-public class CustomType {}
+            public class CustomType {}
 
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandOption('f')]
+                [CommandOption('f')]
-    public CustomType Foo { get; set; }
+                public CustomType Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """
+        );
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -868,23 +908,25 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-public class CustomType : IEnumerable<object>
+            public class CustomType : IEnumerable<object>
-{
+            {
-    public IEnumerator<object> GetEnumerator() => Enumerable.Empty<object>().GetEnumerator();
+                public IEnumerator<object> GetEnumerator() => Enumerable.Empty<object>().GetEnumerator();
 
-    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+                IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
-}
+            }
 
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandOption('f')]
+                [CommandOption('f')]
-    public CustomType Foo { get; set; }
+                public CustomType Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """
+        );
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -909,26 +951,28 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-public class ValidatorA : BindingValidator<int>
+            public class ValidatorA : BindingValidator<int>
-{
+            {
-    public override BindingValidationError Validate(int value) => Ok();
+                public override BindingValidationError Validate(int value) => Ok();
-}
+            }
 
-public class ValidatorB : BindingValidator<int>
+            public class ValidatorB : BindingValidator<int>
-{
+            {
-    public override BindingValidationError Validate(int value) => Error(""Hello world"");
+                public override BindingValidationError Validate(int value) => Error("Hello world");
-}
+            }
 
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandOption('f', Validators = new[] {typeof(ValidatorA), typeof(ValidatorB)})]
+                [CommandOption('f', Validators = new[] {typeof(ValidatorA), typeof(ValidatorB)})]
-    public int Foo { get; set; }
+                public int Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """
+        );
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)
@@ -953,25 +997,27 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-public class CustomType
+            public class CustomType
-{
+            {
-    public string Value { get; }
+                public string Value { get; }
 
-    private CustomType(string value) => Value = value;
+                private CustomType(string value) => Value = value;
 
-    public static CustomType Parse(string value) => throw new Exception(""Hello world"");
+                public static CustomType Parse(string value) => throw new Exception("Hello world");
-}
+            }
 
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandOption('f')]
+                [CommandOption('f')]
-    public CustomType Foo { get; set; }
+                public CustomType Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """
+        );
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
             .UseConsole(FakeConsole)

CliFx.Tests/DirectivesSpecs.cs

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

CliFx.Tests/EnvironmentSpecs.cs

@@ -25,20 +25,21 @@ public class EnvironmentSpecs : SpecsBase
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandOption(""foo"", IsRequired = true, EnvironmentVariable = ""ENV_FOO"")]
+                [CommandOption("foo", IsRequired = true, EnvironmentVariable = "ENV_FOO")]
-    public string Foo { get; set; }
+                public string Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        console.Output.WriteLine(Foo);
+                    console.Output.WriteLine(Foo);
-        return default;
+                    return default;
-    }
+                }
-}
+            }
-");
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -67,20 +68,21 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandOption(""foo"", EnvironmentVariable = ""ENV_FOO"")]
+                [CommandOption("foo", EnvironmentVariable = "ENV_FOO")]
-    public string Foo { get; set; }
+                public string Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        console.Output.WriteLine(Foo);
+                    console.Output.WriteLine(Foo);
-        return default;
+                    return default;
-    }
+                }
-}
+            }
-");
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -109,22 +111,23 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandOption(""foo"", EnvironmentVariable = ""ENV_FOO"")]
+                [CommandOption("foo", EnvironmentVariable = "ENV_FOO")]
-    public IReadOnlyList<string> Foo { get; set; }
+                public IReadOnlyList<string> Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        foreach (var i in Foo)
+                    foreach (var i in Foo)
-            console.Output.WriteLine(i);
+                        console.Output.WriteLine(i);
 
-        return default;
+                    return default;
-    }
+                }
-}
+            }
-");
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -156,20 +159,21 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandOption(""foo"", EnvironmentVariable = ""ENV_FOO"")]
+                [CommandOption("foo", EnvironmentVariable = "ENV_FOO")]
-    public string Foo { get; set; }
+                public string Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        console.Output.WriteLine(Foo);
+                    console.Output.WriteLine(Foo);
-        return default;
+                    return default;
-    }
+                }
-}
+            }
-");
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -198,20 +202,21 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandOption(""foo"", EnvironmentVariable = ""ENV_FOO"")]
+                [CommandOption("foo", EnvironmentVariable = "ENV_FOO")]
-    public string Foo { get; set; }
+                public string Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        console.Output.WriteLine(Foo);
+                    console.Output.WriteLine(Foo);
-        return default;
+                    return default;
-    }
+                }
-}
+            }
-");
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -236,7 +241,7 @@ public class Command : ICommand
         stdOut.Trim().Should().Be("bar");
     }
 
-    [Fact]
+    [Fact(Timeout = 15000)]
     public async Task Environment_variables_are_extracted_automatically()
     {
         // Ensures that the environment variables are properly obtained from

CliFx.Tests/ErrorReportingSpecs.cs

@@ -22,14 +22,15 @@ public class ErrorReportingSpecs : SpecsBase
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    public ValueTask ExecuteAsync(IConsole console) =>
+                public ValueTask ExecuteAsync(IConsole console) =>
-        throw new Exception(""Something went wrong"");
+                    throw new Exception("Something went wrong");
-}
+            }
-");
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -60,14 +61,15 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    public ValueTask ExecuteAsync(IConsole console) =>
+                public ValueTask ExecuteAsync(IConsole console) =>
-        throw new Exception(""Something went wrong"", new Exception(""Another exception""));
+                    throw new Exception("Something went wrong", new Exception("Another exception"));
-}
+            }
-");
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -99,14 +101,15 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    public ValueTask ExecuteAsync(IConsole console) =>
+                public ValueTask ExecuteAsync(IConsole console) =>
-        throw new CommandException(""Something went wrong"", 69);
+                    throw new CommandException("Something went wrong", 69);
-}
+            }
-");
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -134,14 +137,15 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    public ValueTask ExecuteAsync(IConsole console) =>
+                public ValueTask ExecuteAsync(IConsole console) =>
-        throw new CommandException("""", 69);
+                    throw new CommandException("", 69);
-}
+            }
-");
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -172,14 +176,15 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    public ValueTask ExecuteAsync(IConsole console) =>
+                public ValueTask ExecuteAsync(IConsole console) =>
-        throw new CommandException(""Something went wrong"", 69, true);
+                    throw new CommandException("Something went wrong", 69, true);
-}
+            }
-");
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)

CliFx.Tests/HelpTextSpecs.cs

@@ -44,13 +44,14 @@ public class HelpTextSpecs : SpecsBase
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class DefaultCommand : ICommand
+            public class DefaultCommand : ICommand
-{
+            {
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                public ValueTask ExecuteAsync(IConsole console) => default;
-}
+            }
-");
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -77,19 +78,20 @@ public class DefaultCommand : ICommand
         // Arrange
         var commandTypes = DynamicCommandBuilder.CompileMany(
             // language=cs
-            @"
+            """
-[Command(""cmd"")]
+            [Command("cmd")]
-public class NamedCommand : ICommand
+            public class NamedCommand : ICommand
-{
+            {
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                public ValueTask ExecuteAsync(IConsole console) => default;
-}
+            }
 
-[Command(""cmd child"")]
+            [Command("cmd child")]
-public class NamedChildCommand : ICommand
+            public class NamedChildCommand : ICommand
-{
+            {
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                public ValueTask ExecuteAsync(IConsole console) => default;
-}
+            }
-");
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommands(commandTypes)
@@ -116,25 +118,26 @@ public class NamedChildCommand : ICommand
         // Arrange
         var commandTypes = DynamicCommandBuilder.CompileMany(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class DefaultCommand : ICommand
+            public class DefaultCommand : ICommand
-{
+            {
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                public ValueTask ExecuteAsync(IConsole console) => default;
-}
+            }
 
-[Command(""cmd"", Description = ""Description of a named command."")]
+            [Command("cmd", Description = "Description of a named command.")]
-public class NamedCommand : ICommand
+            public class NamedCommand : ICommand
-{
+            {
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                public ValueTask ExecuteAsync(IConsole console) => default;
-}
+            }
 
-[Command(""cmd child"")]
+            [Command("cmd child")]
-public class NamedChildCommand : ICommand
+            public class NamedChildCommand : ICommand
-{
+            {
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                public ValueTask ExecuteAsync(IConsole console) => default;
-}
+            }
-");
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommands(commandTypes)
@@ -160,25 +163,26 @@ public class NamedChildCommand : ICommand
         // Arrange
         var commandTypes = DynamicCommandBuilder.CompileMany(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class DefaultCommand : ICommand
+            public class DefaultCommand : ICommand
-{
+            {
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                public ValueTask ExecuteAsync(IConsole console) => default;
-}
+            }
 
-[Command(""cmd"")]
+            [Command("cmd")]
-public class NamedCommand : ICommand
+            public class NamedCommand : ICommand
-{
+            {
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                public ValueTask ExecuteAsync(IConsole console) => default;
-}
+            }
 
-[Command(""cmd child"", Description = ""Description of a named child command."")]
+            [Command("cmd child", Description = "Description of a named child command.")]
-public class NamedChildCommand : ICommand
+            public class NamedChildCommand : ICommand
-{
+            {
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                public ValueTask ExecuteAsync(IConsole console) => default;
-}
+            }
-");
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommands(commandTypes)
@@ -257,13 +261,15 @@ public class NamedChildCommand : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command(Description = ""Description of the default command."")]
+                
-public class DefaultCommand : ICommand
+                [Command(Description = "Description of the default command.")]
-{
+                public class DefaultCommand : ICommand
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                {
-}
+                    public ValueTask ExecuteAsync(IConsole console) => default;
-");
+                }
+
+                """);
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -292,19 +298,21 @@ public class DefaultCommand : ICommand
         // Arrange
         var commandTypes = DynamicCommandBuilder.CompileMany(
             // language=cs
-            @"
+            """
-[Command]
+                
-public class DefaultCommand : ICommand
+                [Command]
-{
+                public class DefaultCommand : ICommand
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                {
-}
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
+                
+                [Command("cmd")]
+                public class NamedCommand : ICommand
+                {
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
 
-[Command(""cmd"")]
+                """);
-public class NamedCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
 
         var application = new CliApplicationBuilder()
             .AddCommands(commandTypes)
@@ -333,22 +341,24 @@ public class NamedCommand : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+                
-public class Command : ICommand
+                [Command]
-{
+                public class Command : ICommand
-    [CommandParameter(0)]
+                {
-    public string Foo { get; set; }
+                    [CommandParameter(0)]
+                    public string Foo { get; set; }
+                
+                    [CommandParameter(1)]
+                    public string Bar { get; set; }
+                
+                    [CommandParameter(2)]
+                    public IReadOnlyList<string> Baz { get; set; }
+                
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
 
-    [CommandParameter(1)]
+                """);
-    public string Bar { get; set; }
-
-    [CommandParameter(2)]
-    public IReadOnlyList<string> Baz { get; set; }
-
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -378,28 +388,30 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-// Base members appear last in reflection order
+                
-public abstract class CommandBase : ICommand
+                // Base members appear last in reflection order
-{
+                public abstract class CommandBase : ICommand
-    [CommandParameter(0)]
+                {
-    public string Foo { get; set; }
+                    [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;
+                }
 
-    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)
@@ -428,22 +440,24 @@ public class Command : CommandBase
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+                
-public class Command : ICommand
+                [Command]
-{
+                public class Command : ICommand
-    [CommandOption(""foo"", IsRequired = true)]
+                {
-    public string Foo { get; set; }
+                    [CommandOption("foo", IsRequired = true)]
+                    public string Foo { get; set; }
+                
+                    [CommandOption("bar")]
+                    public string Bar { get; set; }
+                
+                    [CommandOption("baz", IsRequired = true)]
+                    public IReadOnlyList<string> Baz { get; set; }
+                
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
 
-    [CommandOption(""bar"")]
+                """);
-    public string Bar { get; set; }
-
-    [CommandOption(""baz"", IsRequired = true)]
-    public IReadOnlyList<string> Baz { get; set; }
-
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -472,19 +486,21 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+                
-public class Command : ICommand
+                [Command]
-{
+                public class Command : ICommand
-    [CommandParameter(0, Name = ""foo"", Description = ""Description of foo."")]
+                {
-    public string Foo { get; set; }
+                    [CommandParameter(0, Name = "foo", Description = "Description of foo.")]
+                    public string Foo { get; set; }
+                
+                    [CommandOption("bar", Description = "Description of bar.")]
+                    public string Bar { get; set; }
+                
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
 
-    [CommandOption(""bar"", Description = ""Description of bar."")]
+                """);
-    public string Bar { get; set; }
-
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -515,13 +531,15 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+                
-public class Command : ICommand
+                [Command]
-{
+                public class Command : ICommand
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                {
-}
+                    public ValueTask ExecuteAsync(IConsole console) => default;
-");
+                }
+
+                """);
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -551,13 +569,15 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command(""cmd"")]
+                
-public class Command : ICommand
+                [Command("cmd")]
-{
+                public class Command : ICommand
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                {
-}
+                    public ValueTask ExecuteAsync(IConsole console) => default;
-");
+                }
+
+                """);
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -589,21 +609,23 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-public enum CustomEnum { One, Two, Three }
+                
+                public enum CustomEnum { One, Two, Three }
+                
+                [Command]
+                public class Command : ICommand
+                {
+                    [CommandParameter(0)]
+                    public CustomEnum Foo { get; set; }
+                
+                    [CommandOption("bar")]
+                    public CustomEnum Bar { get; set; }
+                
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
 
-[Command]
+                """);
-public class Command : ICommand
-{
-    [CommandParameter(0)]
-    public CustomEnum Foo { get; set; }
-
-    [CommandOption(""bar"")]
-    public CustomEnum Bar { get; set; }
-
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -634,21 +656,23 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-public enum CustomEnum { One, Two, Three }
+                
+                public enum CustomEnum { One, Two, Three }
+                
+                [Command]
+                public class Command : ICommand
+                {
+                    [CommandParameter(0)]
+                    public IReadOnlyList<CustomEnum> Foo { get; set; }
+                
+                    [CommandOption("bar")]
+                    public IReadOnlyList<CustomEnum> Bar { get; set; }
+                
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
 
-[Command]
+                """);
-public class Command : ICommand
-{
-    [CommandParameter(0)]
-    public IReadOnlyList<CustomEnum> Foo { get; set; }
-
-    [CommandOption(""bar"")]
-    public IReadOnlyList<CustomEnum> Bar { get; set; }
-
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -679,21 +703,23 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-public enum CustomEnum { One, Two, Three }
+                
+                public enum CustomEnum { One, Two, Three }
+                
+                [Command]
+                public class Command : ICommand
+                {
+                    [CommandParameter(0)]
+                    public CustomEnum? Foo { get; set; }
+                
+                    [CommandOption("bar")]
+                    public IReadOnlyList<CustomEnum?> Bar { get; set; }
+                
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
 
-[Command]
+                """);
-public class Command : ICommand
-{
-    [CommandParameter(0)]
-    public CustomEnum? Foo { get; set; }
-
-    [CommandOption(""bar"")]
-    public IReadOnlyList<CustomEnum?> Bar { get; set; }
-
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -724,21 +750,23 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-public enum CustomEnum { One, Two, Three }
+                
+                public enum CustomEnum { One, Two, Three }
+                
+                [Command]
+                public class Command : ICommand
+                {
+                    [CommandOption("foo", EnvironmentVariable = "ENV_FOO")]
+                    public CustomEnum Foo { get; set; }
+                
+                    [CommandOption("bar", EnvironmentVariable = "ENV_BAR")]
+                    public CustomEnum Bar { get; set; }
+                
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
 
-[Command]
+                """);
-public class Command : ICommand
-{
-    [CommandOption(""foo"", EnvironmentVariable = ""ENV_FOO"")]
-    public CustomEnum Foo { get; set; }
-
-    [CommandOption(""bar"", EnvironmentVariable = ""ENV_BAR"")]
-    public CustomEnum Bar { get; set; }
-
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -768,39 +796,41 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-public enum CustomEnum { One, Two, Three }
+                
+                public enum CustomEnum { One, Two, Three }
+                
+                [Command]
+                public class Command : ICommand
+                {
+                    [CommandOption("foo")]
+                    public object Foo { get; set; } = 42;
+                
+                    [CommandOption("bar")]
+                    public string Bar { get; set; } = "hello";
+                
+                    [CommandOption("baz")]
+                    public IReadOnlyList<string> Baz { get; set; } = new[] {"one", "two", "three"};
+                
+                    [CommandOption("qwe")]
+                    public bool Qwe { get; set; } = true;
+                
+                    [CommandOption("qop")]
+                    public int? Qop { get; set; } = 1337;
+                
+                    [CommandOption("zor")]
+                    public TimeSpan Zor { get; set; } = TimeSpan.FromMinutes(123);
+                
+                    [CommandOption("lol")]
+                    public CustomEnum Lol { get; set; } = CustomEnum.Two;
+                
+                    [CommandOption("hmm", IsRequired = true)]
+                    public string Hmm { get; set; } = "not printed";
+                
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
 
-[Command]
+                """);
-public class Command : ICommand
-{
-    [CommandOption(""foo"")]
-    public object Foo { get; set; } = 42;
-
-    [CommandOption(""bar"")]
-    public string Bar { get; set; } = ""hello"";
-
-    [CommandOption(""baz"")]
-    public IReadOnlyList<string> Baz { get; set; } = new[] {""one"", ""two"", ""three""};
-
-    [CommandOption(""qwe"")]
-    public bool Qwe { get; set; } = true;
-
-    [CommandOption(""qop"")]
-    public int? Qop { get; set; } = 1337;
-
-    [CommandOption(""zor"")]
-    public TimeSpan Zor { get; set; } = TimeSpan.FromMinutes(123);
-
-    [CommandOption(""lol"")]
-    public CustomEnum Lol { get; set; } = CustomEnum.Two;
-
-    [CommandOption(""hmm"", IsRequired = true)]
-    public string Hmm { get; set; } = ""not printed"";
-
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -836,25 +866,27 @@ public class Command : ICommand
         // Arrange
         var commandTypes = DynamicCommandBuilder.CompileMany(
             // language=cs
-            @"
+            """
-[Command(""cmd1"", Description = ""Description of one command."")]
+                
-public class FirstCommand : ICommand
+                [Command("cmd1", Description = "Description of one command.")]
-{
+                public class FirstCommand : ICommand
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                {
-}
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
+                
+                [Command("cmd2", Description = "Description of another command.")]
+                public class SecondCommand : ICommand
+                {
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
+                
+                [Command("cmd2 child", Description = "Description of another command's child command.")]
+                public class SecondCommandChildCommand : ICommand
+                {
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
 
-[Command(""cmd2"", Description = ""Description of another command."")]
+                """);
-public class SecondCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-
-[Command(""cmd2 child"", Description = ""Description of another command's child command."")]
-public class SecondCommandChildCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
 
         var application = new CliApplicationBuilder()
             .AddCommands(commandTypes)
@@ -890,37 +922,39 @@ public class SecondCommandChildCommand : ICommand
         // Arrange
         var commandTypes = DynamicCommandBuilder.CompileMany(
             // language=cs
-            @"
+            """
-[Command(""cmd1"")]
+                
-public class FirstCommand : ICommand
+                [Command("cmd1")]
-{
+                public class FirstCommand : ICommand
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                {
-}
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
+                
+                [Command("cmd1 child1")]
+                public class FirstCommandFirstChildCommand : ICommand
+                {
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
+                
+                [Command("cmd2")]
+                public class SecondCommand : ICommand
+                {
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
+                
+                [Command("cmd2 child11")]
+                public class SecondCommandFirstChildCommand : ICommand
+                {
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
+                
+                [Command("cmd2 child2")]
+                public class SecondCommandSecondChildCommand : ICommand
+                {
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
 
-[Command(""cmd1 child1"")]
+                """);
-public class FirstCommandFirstChildCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-
-[Command(""cmd2"")]
-public class SecondCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-
-[Command(""cmd2 child11"")]
-public class SecondCommandFirstChildCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-
-[Command(""cmd2 child2"")]
-public class SecondCommandSecondChildCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
 
         var application = new CliApplicationBuilder()
             .AddCommands(commandTypes)
@@ -950,25 +984,27 @@ public class SecondCommandSecondChildCommand : ICommand
         // Arrange
         var commandTypes = DynamicCommandBuilder.CompileMany(
             // language=cs
-            @"
+            """
-[Command(""cmd1"")]
+                
-public class FirstCommand : ICommand
+                [Command("cmd1")]
-{
+                public class FirstCommand : ICommand
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                {
-}
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
+                
+                [Command("cmd2 child1")]
+                public class SecondCommandFirstChildCommand : ICommand
+                {
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
+                
+                [Command("cmd2 child2")]
+                public class SecondCommandSecondChildCommand : ICommand
+                {
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
 
-[Command(""cmd2 child1"")]
+                """);
-public class SecondCommandFirstChildCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-
-[Command(""cmd2 child2"")]
-public class SecondCommandSecondChildCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
 
         var application = new CliApplicationBuilder()
             .AddCommands(commandTypes)

CliFx.Tests/OptionBindingSpecs.cs

@@ -22,19 +22,21 @@ public class OptionBindingSpecs : SpecsBase
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandOption(""foo"")]
+                [CommandOption("foo")]
-    public bool Foo { get; set; }
+                public bool Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        console.Output.WriteLine(Foo);
+                    console.Output.WriteLine(Foo);
-        return default;
+                    return default;
-    }
+                }
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -60,19 +62,21 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandOption('f')]
+                [CommandOption('f')]
-    public bool Foo { get; set; }
+                public bool Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        console.Output.WriteLine(Foo);
+                    console.Output.WriteLine(Foo);
-        return default;
+                    return default;
-    }
+                }
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -98,24 +102,26 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandOption(""foo"")]
+                [CommandOption("foo")]
-    public string Foo { get; set; }
+                public string Foo { get; set; }
 
-    [CommandOption(""bar"")]
+                [CommandOption("bar")]
-    public string Bar { get; set; }
+                public string Bar { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        console.Output.WriteLine(""Foo = "" + Foo);
+                    console.Output.WriteLine("Foo = " + Foo);
-        console.Output.WriteLine(""Bar = "" + Bar);
+                    console.Output.WriteLine("Bar = " + Bar);
 
-        return default;
+                    return default;
-    }
+                }
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -144,24 +150,26 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandOption('f')]
+                [CommandOption('f')]
-    public string Foo { get; set; }
+                public string Foo { get; set; }
 
-    [CommandOption('b')]
+                [CommandOption('b')]
-    public string Bar { get; set; }
+                public string Bar { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        console.Output.WriteLine(""Foo = "" + Foo);
+                    console.Output.WriteLine("Foo = " + Foo);
-        console.Output.WriteLine(""Bar = "" + Bar);
+                    console.Output.WriteLine("Bar = " + Bar);
 
-        return default;
+                    return default;
-    }
+                }
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -190,24 +198,26 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandOption('f')]
+                [CommandOption('f')]
-    public string Foo { get; set; }
+                public string Foo { get; set; }
 
-    [CommandOption('b')]
+                [CommandOption('b')]
-    public string Bar { get; set; }
+                public string Bar { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        console.Output.WriteLine(""Foo = "" + Foo);
+                    console.Output.WriteLine("Foo = " + Foo);
-        console.Output.WriteLine(""Bar = "" + Bar);
+                    console.Output.WriteLine("Bar = " + Bar);
 
-        return default;
+                    return default;
-    }
+                }
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -236,21 +246,23 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandOption(""Foo"")]
+                [CommandOption("Foo")]
-    public IReadOnlyList<string> Foo { get; set; }
+                public IReadOnlyList<string> Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        foreach (var i in Foo)
+                    foreach (var i in Foo)
-            console.Output.WriteLine(i);
+                        console.Output.WriteLine(i);
 
-        return default;
+                    return default;
-    }
+                }
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -280,21 +292,23 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandOption('f')]
+                [CommandOption('f')]
-    public IReadOnlyList<string> Foo { get; set; }
+                public IReadOnlyList<string> Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        foreach (var i in Foo)
+                    foreach (var i in Foo)
-            console.Output.WriteLine(i);
+                        console.Output.WriteLine(i);
 
-        return default;
+                    return default;
-    }
+                }
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -324,21 +338,23 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandOption(""foo"")]
+                [CommandOption("foo")]
-    public IReadOnlyList<string> Foo { get; set; }
+                public IReadOnlyList<string> Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        foreach (var i in Foo)
+                    foreach (var i in Foo)
-            console.Output.WriteLine(i);
+                        console.Output.WriteLine(i);
 
-        return default;
+                    return default;
-    }
+                }
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -368,21 +384,23 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandOption('f')]
+                [CommandOption('f')]
-    public IReadOnlyList<string> Foo { get; set; }
+                public IReadOnlyList<string> Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        foreach (var i in Foo)
+                    foreach (var i in Foo)
-            console.Output.WriteLine(i);
+                        console.Output.WriteLine(i);
 
-        return default;
+                    return default;
-    }
+                }
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -412,21 +430,23 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandOption(""foo"", 'f')]
+                [CommandOption("foo", 'f')]
-    public IReadOnlyList<string> Foo { get; set; }
+                public IReadOnlyList<string> Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        foreach (var i in Foo)
+                    foreach (var i in Foo)
-            console.Output.WriteLine(i);
+                        console.Output.WriteLine(i);
 
-        return default;
+                    return default;
-    }
+                }
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -456,24 +476,26 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandOption(""foo"")]
+                [CommandOption("foo")]
-    public string Foo { get; set; }
+                public string Foo { get; set; }
 
-    [CommandOption(""bar"")]
+                [CommandOption("bar")]
-    public string Bar { get; set; } = ""hello"";
+                public string Bar { get; set; } = "hello";
 
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        console.Output.WriteLine(""Foo = "" + Foo);
+                    console.Output.WriteLine("Foo = " + Foo);
-        console.Output.WriteLine(""Bar = "" + Bar);
+                    console.Output.WriteLine("Bar = " + Bar);
 
-        return default;
+                    return default;
-    }
+                }
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -502,55 +524,56 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-public static class SharedContext
+            public static class SharedContext
-{
+            {
-    public static int Foo { get; set; }
+                public static int Foo { get; set; }
 
-    public static bool Bar { get; set; }
+                public static bool Bar { get; set; }
-}
+            }
 
-public interface IHasFoo : ICommand
+            public interface IHasFoo : ICommand
-{
+            {
-    [CommandOption(""foo"")]
+                [CommandOption("foo")]
-    public int Foo
+                public int Foo
-    {
+                {
-        get => SharedContext.Foo;
+                    get => SharedContext.Foo;
-        set => SharedContext.Foo = value;
+                    set => SharedContext.Foo = value;
-    }
+                }
-}
+            }
 
-public interface IHasBar : ICommand
+            public interface IHasBar : ICommand
-{
+            {
-    [CommandOption(""bar"")]
+                [CommandOption("bar")]
-    public bool Bar
+                public bool Bar
-    {
+                {
-        get => SharedContext.Bar;
+                    get => SharedContext.Bar;
-        set => SharedContext.Bar = value;
+                    set => SharedContext.Bar = value;
-    }
+                }
-}
+            }
 
-public interface IHasBaz : ICommand
+            public interface IHasBaz : ICommand
-{
+            {
-    public string Baz { get; set; }
+                public string Baz { get; set; }
-}
+            }
 
-[Command]
+            [Command]
-public class Command : IHasFoo, IHasBar, IHasBaz
+            public class Command : IHasFoo, IHasBar, IHasBaz
-{
+            {
-    [CommandOption(""baz"")]
+                [CommandOption("baz")]
-    public string Baz { get; set; }
+                public string Baz { get; set; }
 
-	public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-	{
+                {
-        console.Output.WriteLine(""Foo = "" + SharedContext.Foo);
+                    console.Output.WriteLine("Foo = " + SharedContext.Foo);
-        console.Output.WriteLine(""Bar = "" + SharedContext.Bar);
+                    console.Output.WriteLine("Bar = " + SharedContext.Bar);
-        console.Output.WriteLine(""Baz = "" + Baz);
+                    console.Output.WriteLine("Baz = " + Baz);
 
-        return default;
+                    return default;
-    }
+                }
-}
+            }
-");
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -579,20 +602,22 @@ public class Command : IHasFoo, IHasBar, IHasBaz
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandOption(""foo"")]
+                [CommandOption("foo")]
-    public string Foo { get; set; }
+                public string Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        console.Output.WriteLine(Foo);
+                    console.Output.WriteLine(Foo);
 
-        return default;
+                    return default;
-    }
+                }
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -618,15 +643,17 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandOption(""foo"", IsRequired = true)]
+                [CommandOption("foo", IsRequired = true)]
-    public string Foo { get; set; }
+                public string Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                public ValueTask ExecuteAsync(IConsole console) => default;
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -652,15 +679,17 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandOption(""foo"", IsRequired = true)]
+                [CommandOption("foo", IsRequired = true)]
-    public string Foo { get; set; }
+                public string Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                public ValueTask ExecuteAsync(IConsole console) => default;
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -686,15 +715,17 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandOption(""foo"", IsRequired = true)]
+                [CommandOption("foo", IsRequired = true)]
-    public IReadOnlyList<string> Foo { get; set; }
+                public IReadOnlyList<string> Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                public ValueTask ExecuteAsync(IConsole console) => default;
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -720,15 +751,17 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandOption(""foo"")]
+                [CommandOption("foo")]
-    public string Foo { get; set; }
+                public string Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                public ValueTask ExecuteAsync(IConsole console) => default;
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -754,15 +787,17 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandOption(""foo"")]
+                [CommandOption("foo")]
-    public string Foo { get; set; }
+                public string Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                public ValueTask ExecuteAsync(IConsole console) => default;
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -781,4 +816,40 @@ public class Command : ICommand
         exitCode.Should().NotBe(0);
         stdErr.Should().Contain("expects a single argument, but provided with multiple");
     }
+
+    [Fact]
+    public async Task Option_binding_fails_if_a_required_property_option_has_not_been_provided()
+    {
+        // Arrange
+        var commandType = DynamicCommandBuilder.Compile(
+            // language=cs
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo")]
+                public required string Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """
+        );
+
+        var application = new CliApplicationBuilder()
+            .AddCommand(commandType)
+            .UseConsole(FakeConsole)
+            .Build();
+
+        // Act
+        var exitCode = await application.RunAsync(
+            Array.Empty<string>(),
+            new Dictionary<string, string>()
+        );
+
+        var stdErr = FakeConsole.ReadErrorString();
+
+        // Assert
+        exitCode.Should().NotBe(0);
+        stdErr.Should().Contain("Missing required option(s)");
+    }
 }

CliFx.Tests/ParameterBindingSpecs.cs

@@ -21,24 +21,26 @@ public class ParameterBindingSpecs : SpecsBase
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandParameter(0)]
+                [CommandParameter(0)]
-    public string Foo { get; set; }
+                public string Foo { get; set; }
 
-    [CommandParameter(1)]
+                [CommandParameter(1)]
-    public string Bar { get; set; }
+                public string Bar { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        console.Output.WriteLine(""Foo = "" + Foo);
+                    console.Output.WriteLine("Foo = " + Foo);
-        console.Output.WriteLine(""Bar = "" + Bar);
+                    console.Output.WriteLine("Bar = " + Bar);
 
-        return default;
+                    return default;
-    }
+                }
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -67,33 +69,35 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandParameter(0)]
+                [CommandParameter(0)]
-    public string Foo { get; set; }
+                public string Foo { get; set; }
 
-    [CommandParameter(1)]
+                [CommandParameter(1)]
-    public string Bar { get; set; }
+                public string Bar { get; set; }
 
-    [CommandParameter(2)]
+                [CommandParameter(2)]
-    public IReadOnlyList<string> Baz { get; set; }
+                public IReadOnlyList<string> Baz { get; set; }
 
-    [CommandOption(""boo"")]
+                [CommandOption("boo")]
-    public string Boo { get; set; }
+                public string Boo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        console.Output.WriteLine(""Foo = "" + Foo);
+                    console.Output.WriteLine("Foo = " + Foo);
-        console.Output.WriteLine(""Bar = "" + Bar);
+                    console.Output.WriteLine("Bar = " + Bar);
 
-        foreach (var i in Baz)
+                    foreach (var i in Baz)
-            console.Output.WriteLine(""Baz = "" + i);
+                        console.Output.WriteLine("Baz = " + i);
 
-        return default;
+                    return default;
-    }
+                }
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -125,24 +129,26 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandParameter(0)]
+                [CommandParameter(0)]
-    public string Foo { get; set; }
+                public string Foo { get; set; }
 
-    [CommandParameter(1, IsRequired = false)]
+                [CommandParameter(1, IsRequired = false)]
-    public string Bar { get; set; } = ""xyz"";
+                public string Bar { get; set; } = "xyz";
 
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        console.Output.WriteLine(""Foo = "" + Foo);
+                    console.Output.WriteLine("Foo = " + Foo);
-        console.Output.WriteLine(""Bar = "" + Bar);
+                    console.Output.WriteLine("Bar = " + Bar);
 
-        return default;
+                    return default;
-    }
+                }
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -171,18 +177,20 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandParameter(0)]
+                [CommandParameter(0)]
-    public string Foo { get; set; }
+                public string Foo { get; set; }
 
-    [CommandParameter(1)]
+                [CommandParameter(1)]
-    public string Bar { get; set; }
+                public string Bar { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                public ValueTask ExecuteAsync(IConsole console) => default;
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -208,18 +216,20 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandParameter(0)]
+                [CommandParameter(0)]
-    public string Foo { get; set; }
+                public string Foo { get; set; }
 
-    [CommandParameter(1)]
+                [CommandParameter(1)]
-    public IReadOnlyList<string> Bar { get; set; }
+                public IReadOnlyList<string> Bar { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                public ValueTask ExecuteAsync(IConsole console) => default;
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -245,18 +255,20 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    [CommandParameter(0)]
+                [CommandParameter(0)]
-    public string Foo { get; set; }
+                public string Foo { get; set; }
 
-    [CommandParameter(1)]
+                [CommandParameter(1)]
-    public string Bar { get; set; }
+                public string Bar { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                public ValueTask ExecuteAsync(IConsole console) => default;
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)

CliFx.Tests/RoutingSpecs.cs

@@ -21,37 +21,38 @@ public class RoutingSpecs : SpecsBase
         // Arrange
         var commandTypes = DynamicCommandBuilder.CompileMany(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class DefaultCommand : ICommand
+            public class DefaultCommand : ICommand
-{
+            {
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        console.Output.WriteLine(""default"");
+                    console.Output.WriteLine("default");
-        return default;
+                    return default;
-    }
+                }
-}
+            }
 
-[Command(""cmd"")]
+            [Command("cmd")]
-public class NamedCommand : ICommand
+            public class NamedCommand : ICommand
-{
+            {
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        console.Output.WriteLine(""cmd"");
+                    console.Output.WriteLine("cmd");
-        return default;
+                    return default;
-    }
+                }
-}
+            }
 
-[Command(""cmd child"")]
+            [Command("cmd child")]
-public class NamedChildCommand : ICommand
+            public class NamedChildCommand : ICommand
-{
+            {
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        console.Output.WriteLine(""cmd child"");
+                    console.Output.WriteLine("cmd child");
-        return default;
+                    return default;
-    }
+                }
-}
+            }
-");
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommands(commandTypes)
@@ -77,37 +78,38 @@ public class NamedChildCommand : ICommand
         // Arrange
         var commandTypes = DynamicCommandBuilder.CompileMany(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class DefaultCommand : ICommand
+            public class DefaultCommand : ICommand
-{
+            {
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        console.Output.WriteLine(""default"");
+                    console.Output.WriteLine("default");
-        return default;
+                    return default;
-    }
+                }
-}
+            }
 
-[Command(""cmd"")]
+            [Command("cmd")]
-public class NamedCommand : ICommand
+            public class NamedCommand : ICommand
-{
+            {
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        console.Output.WriteLine(""cmd"");
+                    console.Output.WriteLine("cmd");
-        return default;
+                    return default;
-    }
+                }
-}
+            }
 
-[Command(""cmd child"")]
+            [Command("cmd child")]
-public class NamedChildCommand : ICommand
+            public class NamedChildCommand : ICommand
-{
+            {
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        console.Output.WriteLine(""cmd child"");
+                    console.Output.WriteLine("cmd child");
-        return default;
+                    return default;
-    }
+                }
-}
+            }
-");
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommands(commandTypes)
@@ -133,37 +135,38 @@ public class NamedChildCommand : ICommand
         // Arrange
         var commandTypes = DynamicCommandBuilder.CompileMany(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class DefaultCommand : ICommand
+            public class DefaultCommand : ICommand
-{
+            {
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        console.Output.WriteLine(""default"");
+                    console.Output.WriteLine("default");
-        return default;
+                    return default;
-    }
+                }
-}
+            }
 
-[Command(""cmd"")]
+            [Command("cmd")]
-public class NamedCommand : ICommand
+            public class NamedCommand : ICommand
-{
+            {
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        console.Output.WriteLine(""cmd"");
+                    console.Output.WriteLine("cmd");
-        return default;
+                    return default;
-    }
+                }
-}
+            }
 
-[Command(""cmd child"")]
+            [Command("cmd child")]
-public class NamedChildCommand : ICommand
+            public class NamedChildCommand : ICommand
-{
+            {
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        console.Output.WriteLine(""cmd child"");
+                    console.Output.WriteLine("cmd child");
-        return default;
+                    return default;
-    }
+                }
-}
+            }
-");
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommands(commandTypes)

CliFx.Tests/TypeActivationSpecs.cs

@@ -23,16 +23,18 @@ public class TypeActivationSpecs : SpecsBase
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        console.Output.WriteLine(""foo"");
+                    console.Output.WriteLine("foo");
-        return default;
+                    return default;
-    }
+                }
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -59,14 +61,16 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    public Command(string foo) {}
+                public Command(string foo) {}
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
+                public ValueTask ExecuteAsync(IConsole console) => default;
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -93,20 +97,22 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    private readonly string _foo;
+                private readonly string _foo;
 
-    public Command(string foo) => _foo = foo;
+                public Command(string foo) => _foo = foo;
 
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        console.Output.WriteLine(_foo);
+                    console.Output.WriteLine(_foo);
-        return default;
+                    return default;
-    }
+                }
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -133,20 +139,22 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    private readonly string _foo;
+                private readonly string _foo;
 
-    public Command(string foo) => _foo = foo;
+                public Command(string foo) => _foo = foo;
 
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        console.Output.WriteLine(_foo);
+                    console.Output.WriteLine(_foo);
-        return default;
+                    return default;
-    }
+                }
-}");
+            }
+            """
+        );
 
         var serviceProvider = new ServiceCollection()
             .AddSingleton(commandType, Activator.CreateInstance(commandType, "Hello world")!)
@@ -177,16 +185,18 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
+            """
-[Command]
+            [Command]
-public class Command : ICommand
+            public class Command : ICommand
-{
+            {
-    public ValueTask ExecuteAsync(IConsole console)
+                public ValueTask ExecuteAsync(IConsole console)
-    {
+                {
-        console.Output.WriteLine(""foo"");
+                    console.Output.WriteLine("foo");
-        return default;
+                    return default;
-    }
+                }
-}");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)

CliFx.Tests/Utils/DynamicCommandBuilder.cs

@@ -61,7 +61,7 @@ internal static class DynamicCommandBuilder
         var compilation = CSharpCompilation.Create(
             "CliFxTests_DynamicAssembly_" + Guid.NewGuid(),
             new[] {ast},
-            ReferenceAssemblies.Net50
+            Net70.References.All
                 .Append(MetadataReference.CreateFromFile(typeof(ICommand).Assembly.Location))
                 .Append(MetadataReference.CreateFromFile(typeof(DynamicCommandBuilder).Assembly.Location)),
             // DLL to avoid having to define the Main() method
@@ -76,9 +76,10 @@ internal static class DynamicCommandBuilder
         if (compilationErrors.Any())
         {
             throw new InvalidOperationException(
-                "Failed to compile code." +
+                $"""
-                Environment.NewLine +
+                Failed to compile code.
-                string.Join(Environment.NewLine, compilationErrors.Select(e => e.ToString()))
+                {string.Join(Environment.NewLine, compilationErrors.Select(e => e.ToString()))}
+                """
             );
         }
 
@@ -94,9 +95,10 @@ internal static class DynamicCommandBuilder
         if (emitErrors.Any())
         {
             throw new InvalidOperationException(
-                "Failed to emit code." +
+                $"""
-                Environment.NewLine +
+                Failed to emit code.
-                string.Join(Environment.NewLine, emitErrors.Select(e => e.ToString()))
+                {string.Join(Environment.NewLine, emitErrors.Select(e => e.ToString()))}
+                """
             );
         }
 

CliFx/ApplicationConfiguration.cs

@@ -24,7 +24,7 @@ public class ApplicationConfiguration
     public bool IsPreviewModeAllowed { get; }
 
     /// <summary>
-    /// Initializes an instance of <see cref="ApplicationConfiguration"/>.
+    /// Initializes an instance of <see cref="ApplicationConfiguration" />.
     /// </summary>
     public ApplicationConfiguration(
         IReadOnlyList<Type> commandTypes,

CliFx/ApplicationMetadata.cs

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

CliFx/Attributes/CommandAttribute.cs

@@ -26,7 +26,7 @@ public sealed class CommandAttribute : Attribute
     public string? Description { get; set; }
 
     /// <summary>
-    /// Initializes an instance of <see cref="CommandAttribute"/>.
+    /// Initializes an instance of <see cref="CommandAttribute" />.
     /// </summary>
     public CommandAttribute(string name)
     {
@@ -34,7 +34,7 @@ public sealed class CommandAttribute : Attribute
     }
 
     /// <summary>
-    /// Initializes an instance of <see cref="CommandAttribute"/>.
+    /// Initializes an instance of <see cref="CommandAttribute" />.
     /// </summary>
     public CommandAttribute()
     {

CliFx/Attributes/CommandOptionAttribute.cs

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

CliFx/Attributes/CommandParameterAttribute.cs

@@ -47,11 +47,11 @@ public sealed class CommandParameterAttribute : Attribute
     public string? Description { get; set; }
 
     /// <summary>
-    /// Custom converter used for mapping the raw command line argument into
+    /// Custom converter used for mapping the raw command-line argument into
     /// a value expected by the underlying property.
     /// </summary>
     /// <remarks>
-    /// Converter must derive from <see cref="BindingConverter{T}"/>.
+    /// Converter must derive from <see cref="BindingConverter{T}" />.
     /// </remarks>
     public Type? Converter { get; set; }
 
@@ -60,12 +60,12 @@ public sealed class CommandParameterAttribute : Attribute
     /// property, after it has been bound.
     /// </summary>
     /// <remarks>
-    /// Validators must derive from <see cref="BindingValidator{T}"/>.
+    /// Validators must derive from <see cref="BindingValidator{T}" />.
     /// </remarks>
     public Type[] Validators { get; set; } = Array.Empty<Type>();
 
     /// <summary>
-    /// Initializes an instance of <see cref="CommandParameterAttribute"/>.
+    /// Initializes an instance of <see cref="CommandParameterAttribute" />.
     /// </summary>
     public CommandParameterAttribute(int order)
     {

CliFx/CliApplication.cs

@@ -2,6 +2,7 @@ using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
+using System.Runtime.InteropServices;
 using System.Threading.Tasks;
 using CliFx.Exceptions;
 using CliFx.Formatting;
@@ -14,7 +15,7 @@ using CliFx.Utils.Extensions;
 namespace CliFx;
 
 /// <summary>
-/// Command line application facade.
+/// Command-line application facade.
 /// </summary>
 public class CliApplication
 {
@@ -34,7 +35,7 @@ public class CliApplication
     private readonly CommandBinder _commandBinder;
 
     /// <summary>
-    /// Initializes an instance of <see cref="CliApplication"/>.
+    /// Initializes an instance of <see cref="CliApplication" />.
     /// </summary>
     public CliApplication(
         ApplicationMetadata metadata,
@@ -163,7 +164,7 @@ public class CliApplication
     }
 
     /// <summary>
-    /// Runs the application with the specified command line arguments and environment variables.
+    /// Runs the application with the specified command-line arguments and environment variables.
     /// Returns an exit code which indicates whether the application completed successfully.
     /// </summary>
     /// <remarks>
@@ -206,7 +207,7 @@ public class CliApplication
     }
 
     /// <summary>
-    /// Runs the application with the specified command line arguments.
+    /// Runs the application with the specified command-line arguments.
     /// Environment variables are resolved automatically.
     /// Returns an exit code which indicates whether the application completed successfully.
     /// </summary>
@@ -216,16 +217,18 @@ public class CliApplication
     /// </remarks>
     public async ValueTask<int> RunAsync(IReadOnlyList<string> commandLineArguments) => await RunAsync(
         commandLineArguments,
-        // Use case-sensitive comparison because environment variables are
-        // case-sensitive on Linux and macOS (but not on Windows).
         Environment
             .GetEnvironmentVariables()
-            .ToDictionary<string, string>(StringComparer.Ordinal)
+            .ToDictionary<string, string>(
+                RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
+                    ? StringComparer.OrdinalIgnoreCase
+                    : StringComparer.Ordinal
+            )
     );
 
     /// <summary>
     /// Runs the application.
-    /// Command line arguments and environment variables are resolved automatically.
+    /// Command-line arguments and environment variables are resolved automatically.
     /// Returns an exit code which indicates whether the application completed successfully.
     /// </summary>
     /// <remarks>

CliFx/CliApplicationBuilder.cs

@@ -12,7 +12,7 @@ using CliFx.Utils.Extensions;
 namespace CliFx;
 
 /// <summary>
-/// Builder for <see cref="CliApplication"/>.
+/// Builder for <see cref="CliApplication" />.
 /// </summary>
 public partial class CliApplicationBuilder
 {
@@ -58,8 +58,8 @@ public partial class CliApplicationBuilder
     /// Adds commands from the specified assembly to the application.
     /// </summary>
     /// <remarks>
-    /// This method looks for public non-abstract classes that implement <see cref="ICommand"/>
+    /// This method looks for public non-abstract classes that implement <see cref="ICommand" />
-    /// and are annotated by <see cref="CommandAttribute"/>.
+    /// and are annotated by <see cref="CommandAttribute" />.
     /// </remarks>
     public CliApplicationBuilder AddCommandsFrom(Assembly commandAssembly)
     {
@@ -73,8 +73,8 @@ public partial class CliApplicationBuilder
     /// Adds commands from the specified assemblies to the application.
     /// </summary>
     /// <remarks>
-    /// This method looks for public non-abstract classes that implement <see cref="ICommand"/>
+    /// This method looks for public non-abstract classes that implement <see cref="ICommand" />
-    /// and are annotated by <see cref="CommandAttribute"/>.
+    /// and are annotated by <see cref="CommandAttribute" />.
     /// </remarks>
     public CliApplicationBuilder AddCommandsFrom(IEnumerable<Assembly> commandAssemblies)
     {
@@ -88,8 +88,8 @@ public partial class CliApplicationBuilder
     /// Adds commands from the calling assembly to the application.
     /// </summary>
     /// <remarks>
-    /// This method looks for public non-abstract classes that implement <see cref="ICommand"/>
+    /// This method looks for public non-abstract classes that implement <see cref="ICommand" />
-    /// and are annotated by <see cref="CommandAttribute"/>.
+    /// and are annotated by <see cref="CommandAttribute" />.
     /// </remarks>
     public CliApplicationBuilder AddCommandsFromThisAssembly() => AddCommandsFrom(Assembly.GetCallingAssembly());
 
@@ -159,7 +159,7 @@ public partial class CliApplicationBuilder
     }
 
     /// <summary>
-    /// Configures the application to use the specified implementation of <see cref="IConsole"/>.
+    /// Configures the application to use the specified implementation of <see cref="IConsole" />.
     /// </summary>
     public CliApplicationBuilder UseConsole(IConsole console)
     {
@@ -168,7 +168,7 @@ public partial class CliApplicationBuilder
     }
 
     /// <summary>
-    /// Configures the application to use the specified implementation of <see cref="ITypeActivator"/>.
+    /// Configures the application to use the specified implementation of <see cref="ITypeActivator" />.
     /// </summary>
     public CliApplicationBuilder UseTypeActivator(ITypeActivator typeActivator)
     {
@@ -189,7 +189,7 @@ public partial class CliApplicationBuilder
         UseTypeActivator(serviceProvider.GetService);
 
     /// <summary>
-    /// Creates a configured instance of <see cref="CliApplication"/>.
+    /// Creates a configured instance of <see cref="CliApplication" />.
     /// </summary>
     public CliApplication Build()
     {

CliFx/CliFx.csproj

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

CliFx/CommandBinder.cs

@@ -31,7 +31,7 @@ internal class CommandBinder
             return converter.Convert(rawValue);
         }
 
-        // Assignable from string (e.g. string itself, object, etc)
+        // Assignable from a string (e.g. string itself, object, etc)
         if (targetType.IsAssignableFrom(typeof(string)))
         {
             return rawValue;
@@ -77,7 +77,7 @@ internal class CommandBinder
                 : null;
         }
 
-        // String-constructible (FileInfo, etc)
+        // String-constructable (FileInfo, etc)
         var stringConstructor = targetType.GetConstructor(new[] { typeof(string) });
         if (stringConstructor is not null)
         {
@@ -99,11 +99,11 @@ internal class CommandBinder
         }
 
         throw CliFxException.InternalError(
-            $"{memberSchema.GetKind()} {memberSchema.GetFormattedIdentifier()} has an unsupported underlying property type." +
+            $"""
-            Environment.NewLine +
+            {memberSchema.GetKind()} {memberSchema.GetFormattedIdentifier()} has an unsupported underlying property type.
-            $"There is no known way to convert a string value into an instance of type `{targetType.FullName}`." +
+            There is no known way to convert a string value into an instance of type `{targetType.FullName}`
-            Environment.NewLine +
+            To fix this, either change the property to use a supported type or configure a custom converter.
-            "To fix this, either change the property to use a supported type or configure a custom converter."
+            """
         );
     }
 
@@ -125,7 +125,7 @@ internal class CommandBinder
             return array;
         }
 
-        // Array-constructible (List<T>, HashSet<T>, etc)
+        // Array-constructable (List<T>, HashSet<T>, etc)
         var arrayConstructor = targetEnumerableType.GetConstructor(new[] { arrayType });
         if (arrayConstructor is not null)
         {
@@ -133,11 +133,11 @@ internal class CommandBinder
         }
 
         throw CliFxException.InternalError(
-            $"{memberSchema.GetKind()} {memberSchema.GetFormattedIdentifier()} has an unsupported underlying property type." +
+            $"""
-            Environment.NewLine +
+            {memberSchema.GetKind()} {memberSchema.GetFormattedIdentifier()} has an unsupported underlying property type.
-            $"There is no known way to convert an array of `{targetElementType.FullName}` into an instance of type `{targetEnumerableType.FullName}`." +
+            There is no known way to convert an array of `{targetElementType.FullName}` into an instance of type `{targetEnumerableType.FullName}`.
-            Environment.NewLine +
+            To fix this, change the property to use a type which can be assigned from an array or a type that has a constructor which accepts an array.
-            "To fix this, change the property to use a type which can be assigned from an array or a type that has a constructor which accepts an array."
+            """
         );
     }
 
@@ -169,20 +169,21 @@ internal class CommandBinder
                 : ex.Message;
 
             throw CliFxException.UserError(
-                $"{memberSchema.GetKind()} {memberSchema.GetFormattedIdentifier()} cannot be set from the provided argument(s):" +
+                $"""
-                Environment.NewLine +
+                {memberSchema.GetKind()} {memberSchema.GetFormattedIdentifier()} cannot be set from the provided argument(s):
-                rawValues.Select(v => '<' + v + '>').JoinToString(" ") +
+                {rawValues.Select(v => '<' + v + '>').JoinToString(" ")}
-                Environment.NewLine +
+                Error: {errorMessage}
-                $"Error: {errorMessage}",
+                """,
                 ex
             );
         }
 
         // Mismatch (scalar but too many values)
         throw CliFxException.UserError(
-            $"{memberSchema.GetKind()} {memberSchema.GetFormattedIdentifier()} expects a single argument, but provided with multiple:" +
+            $"""
-            Environment.NewLine +
+            {memberSchema.GetKind()} {memberSchema.GetFormattedIdentifier()} expects a single argument, but provided with multiple:
-            rawValues.Select(v => '<' + v + '>').JoinToString(" ")
+            {rawValues.Select(v => '<' + v + '>').JoinToString(" ")}
+            """
         );
     }
 
@@ -202,11 +203,11 @@ internal class CommandBinder
         if (errors.Any())
         {
             throw CliFxException.UserError(
-                $"{memberSchema.GetKind()} {memberSchema.GetFormattedIdentifier()} has been provided with an invalid value." +
+                $"""
-                Environment.NewLine +
+                {memberSchema.GetKind()} {memberSchema.GetFormattedIdentifier()} has been provided with an invalid value.
-                "Error(s):" +
+                Error(s):
-                Environment.NewLine +
+                {errors.Select(e => "- " + e.Message).JoinToString(Environment.NewLine)}
-                errors.Select(e => "- " + e.Message).JoinToString(Environment.NewLine)
+                """
             );
         }
     }
@@ -264,22 +265,20 @@ internal class CommandBinder
         if (remainingParameterInputs.Any())
         {
             throw CliFxException.UserError(
-                "Unexpected parameter(s):" +
+                $"""
-                Environment.NewLine +
+                Unexpected parameter(s):
-                remainingParameterInputs
+                {remainingParameterInputs.Select(p => p.GetFormattedIdentifier()).JoinToString(" ")}
-                    .Select(p => p.GetFormattedIdentifier())
+                """
-                    .JoinToString(" ")
             );
         }
 
         if (remainingRequiredParameterSchemas.Any())
         {
             throw CliFxException.UserError(
-                "Missing required parameter(s):" +
+                $"""
-                Environment.NewLine +
+                Missing required parameter(s):
-                remainingRequiredParameterSchemas
+                {remainingRequiredParameterSchemas.Select(p => p.GetFormattedIdentifier()).JoinToString(" ")}
-                    .Select(p => p.GetFormattedIdentifier())
+                """
-                    .JoinToString(" ")
             );
         }
     }
@@ -308,7 +307,7 @@ internal class CommandBinder
 
                 BindMember(optionSchema, commandInstance, rawValues);
 
-                // Required options require at least one value to be set
+                // Required options need at least one value to be set
                 if (rawValues.Any())
                     remainingRequiredOptionSchemas.Remove(optionSchema);
             }
@@ -321,7 +320,7 @@ internal class CommandBinder
 
                 BindMember(optionSchema, commandInstance, rawValues);
 
-                // Required options require at least one value to be set
+                // Required options need at least one value to be set
                 if (rawValues.Any())
                     remainingRequiredOptionSchemas.Remove(optionSchema);
             }
@@ -337,22 +336,20 @@ internal class CommandBinder
         if (remainingOptionInputs.Any())
         {
             throw CliFxException.UserError(
-                "Unrecognized option(s):" +
+                $"""
-                Environment.NewLine +
+                Unrecognized option(s):
-                remainingOptionInputs
+                {remainingOptionInputs.Select(o => o.GetFormattedIdentifier()).JoinToString(", ")}
-                    .Select(o => o.GetFormattedIdentifier())
+                """
-                    .JoinToString(", ")
             );
         }
 
         if (remainingRequiredOptionSchemas.Any())
         {
             throw CliFxException.UserError(
-                "Missing required option(s):" +
+                $"""
-                Environment.NewLine +
+                Missing required option(s):
-                remainingRequiredOptionSchemas
+                {remainingRequiredOptionSchemas.Select(o => o.GetFormattedIdentifier()).JoinToString(", ")}
-                    .Select(o => o.GetFormattedIdentifier())
+                """
-                    .JoinToString(", ")
             );
         }
     }

CliFx/Exceptions/CliFxException.cs

@@ -24,7 +24,7 @@ public partial class CliFxException : Exception
     public bool ShowHelp { get; }
 
     /// <summary>
-    /// Initializes an instance of <see cref="CliFxException"/>.
+    /// Initializes an instance of <see cref="CliFxException" />.
     /// </summary>
     public CliFxException(
         string message,

CliFx/Exceptions/CommandException.cs

@@ -9,7 +9,7 @@ namespace CliFx.Exceptions;
 public class CommandException : CliFxException
 {
     /// <summary>
-    /// Initializes an instance of <see cref="CommandException"/>.
+    /// Initializes an instance of <see cref="CommandException" />.
     /// </summary>
     public CommandException(
         string message,

CliFx/Extensibility/BindingConverter.cs

@@ -12,7 +12,7 @@ internal interface IBindingConverter
 public abstract class BindingConverter<T> : IBindingConverter
 {
     /// <summary>
-    /// Parses value from a raw command line argument.
+    /// Parses value from a raw command-line argument.
     /// </summary>
     public abstract T Convert(string? rawValue);
 

CliFx/Extensibility/BindingValidationError.cs

@@ -11,7 +11,7 @@ public class BindingValidationError
     public string Message { get; }
 
     /// <summary>
-    /// Initializes an instance of <see cref="BindingValidationError"/>.
+    /// Initializes an instance of <see cref="BindingValidationError" />.
     /// </summary>
     public BindingValidationError(string message) => Message = message;
 }

CliFx/Extensibility/BindingValidator.cs

@@ -26,7 +26,7 @@ public abstract class BindingValidator<T> : IBindingValidator
     /// Returns null if validation is successful, or an error in case of failure.
     /// </summary>
     /// <remarks>
-    /// You can use the utility methods <see cref="Ok"/> and <see cref="Error"/> to
+    /// You can use the utility methods <see cref="Ok" /> and <see cref="Error" /> to
     /// create an appropriate result.
     /// </remarks>
     public abstract BindingValidationError? Validate(T? value);

CliFx/Formatting/CommandInputConsoleFormatter.cs

@@ -13,7 +13,7 @@ internal class CommandInputConsoleFormatter : ConsoleFormatter
 
     private void WriteCommandLineArguments(CommandInput commandInput)
     {
-        Write("Command line:");
+        Write("Command-line:");
         WriteLine();
 
         WriteHorizontalMargin();

CliFx/Formatting/HelpConsoleFormatter.cs

@@ -206,7 +206,7 @@ internal class HelpConsoleFormatter : ConsoleFormatter
                 Write('.');
                 Write(' ');
             }
-            
+
             // Default value
             if (!parameterSchema.IsRequired)
             {
@@ -367,7 +367,9 @@ internal class HelpConsoleFormatter : ConsoleFormatter
     {
         var childCommandSchemas = _context
             .ApplicationSchema
-            .GetChildCommands(_context.CommandSchema.Name);
+            .GetChildCommands(_context.CommandSchema.Name)
+            .OrderBy(a => a.Name, StringComparer.Ordinal)
+            .ToArray();
 
         if (!childCommandSchemas.Any())
             return;
@@ -402,7 +404,9 @@ internal class HelpConsoleFormatter : ConsoleFormatter
             // Child commands of child command
             var grandChildCommandSchemas = _context
                 .ApplicationSchema
-                .GetChildCommands(childCommandSchema.Name);
+                .GetChildCommands(childCommandSchema.Name)
+                .OrderBy(c => c.Name, StringComparer.Ordinal)
+                .ToArray();
 
             if (grandChildCommandSchemas.Any())
             {

CliFx/ICommand.cs

@@ -4,12 +4,12 @@ using CliFx.Infrastructure;
 namespace CliFx;
 
 /// <summary>
-/// Entry point through which the user interacts with the command line application.
+/// Entry point through which the user interacts with the command-line application.
 /// </summary>
 public interface ICommand
 {
     /// <summary>
-    /// Executes the command using the specified implementation of <see cref="IConsole"/>.
+    /// Executes the command using the specified implementation of <see cref="IConsole" />.
     /// </summary>
     /// <remarks>
     /// If the execution of the command is not asynchronous, simply end the method with

CliFx/Infrastructure/ConsoleReader.cs

@@ -7,7 +7,7 @@ using System.Threading.Tasks;
 namespace CliFx.Infrastructure;
 
 /// <summary>
-/// Implements a <see cref="TextReader"/> for reading characters from a console stream.
+/// Implements a <see cref="TextReader" /> for reading characters from a console stream.
 /// </summary>
 // Both the underlying stream AND the stream reader must be synchronized!
 // https://github.com/Tyrrrz/CliFx/issues/123
@@ -19,7 +19,7 @@ public partial class ConsoleReader : StreamReader
     public IConsole Console { get; }
 
     /// <summary>
-    /// Initializes an instance of <see cref="ConsoleReader"/>.
+    /// Initializes an instance of <see cref="ConsoleReader" />.
     /// </summary>
     public ConsoleReader(IConsole console, Stream stream, Encoding encoding)
         : base(stream, encoding, false, 4096)
@@ -28,7 +28,7 @@ public partial class ConsoleReader : StreamReader
     }
 
     /// <summary>
-    /// Initializes an instance of <see cref="ConsoleReader"/>.
+    /// Initializes an instance of <see cref="ConsoleReader" />.
     /// </summary>
     public ConsoleReader(IConsole console, Stream stream)
         : this(console, stream, System.Console.InputEncoding)

CliFx/Infrastructure/ConsoleWriter.cs

@@ -8,7 +8,7 @@ using CliFx.Utils;
 namespace CliFx.Infrastructure;
 
 /// <summary>
-/// Implements a <see cref="TextWriter"/> for writing characters to a console stream.
+/// Implements a <see cref="TextWriter" /> for writing characters to a console stream.
 /// </summary>
 // Both the underlying stream AND the stream writer must be synchronized!
 // https://github.com/Tyrrrz/CliFx/issues/123
@@ -20,7 +20,7 @@ public partial class ConsoleWriter : StreamWriter
     public IConsole Console { get; }
 
     /// <summary>
-    /// Initializes an instance of <see cref="ConsoleWriter"/>.
+    /// Initializes an instance of <see cref="ConsoleWriter" />.
     /// </summary>
     public ConsoleWriter(IConsole console, Stream stream, Encoding encoding)
         : base(stream, encoding.WithoutPreamble(), 256)
@@ -29,7 +29,7 @@ public partial class ConsoleWriter : StreamWriter
     }
 
     /// <summary>
-    /// Initializes an instance of <see cref="ConsoleWriter"/>.
+    /// Initializes an instance of <see cref="ConsoleWriter" />.
     /// </summary>
     public ConsoleWriter(IConsole console, Stream stream)
         : this(console, stream, System.Console.OutputEncoding)

CliFx/Infrastructure/DefaultTypeActivator.cs

@@ -4,7 +4,7 @@ using CliFx.Exceptions;
 namespace CliFx.Infrastructure;
 
 /// <summary>
-/// Implementation of <see cref="ITypeActivator"/> that instantiates an object
+/// Implementation of <see cref="ITypeActivator" /> that instantiates an object
 /// by using its parameterless constructor.
 /// </summary>
 public class DefaultTypeActivator : ITypeActivator
@@ -20,11 +20,11 @@ public class DefaultTypeActivator : ITypeActivator
         catch (MemberAccessException ex)
         {
             throw CliFxException.InternalError(
-                $"Failed to create an instance of type `{type.FullName}`, could not access the constructor." +
+                $"""
-                Environment.NewLine +
+                Failed to create an instance of type `{type.FullName}`, could not access the constructor.
-                "Default type activator is only capable of instantiating a type if it has a public parameterless constructor." +
+                Default type activator is only capable of instantiating a type if it has a public parameterless constructor.
-                Environment.NewLine +
+                To fix this, either add a parameterless constructor to the type or configure a custom activator for the application.
-                "To fix this, either add a parameterless constructor to the type or configure a custom activator for the application.",
+                """,
                 ex
             );
         }

CliFx/Infrastructure/DelegateTypeActivator.cs

@@ -4,7 +4,7 @@ using CliFx.Exceptions;
 namespace CliFx.Infrastructure;
 
 /// <summary>
-/// Implementation of <see cref="ITypeActivator"/> that instantiates an object
+/// Implementation of <see cref="ITypeActivator" /> that instantiates an object
 /// by using a predefined function.
 /// </summary>
 public class DelegateTypeActivator : ITypeActivator
@@ -12,7 +12,7 @@ public class DelegateTypeActivator : ITypeActivator
     private readonly Func<Type, object> _func;
 
     /// <summary>
-    /// Initializes an instance of <see cref="DelegateTypeActivator"/>.
+    /// Initializes an instance of <see cref="DelegateTypeActivator" />.
     /// </summary>
     public DelegateTypeActivator(Func<Type, object> func) => _func = func;
 
@@ -24,11 +24,11 @@ public class DelegateTypeActivator : ITypeActivator
         if (instance is null)
         {
             throw CliFxException.InternalError(
-                $"Failed to create an instance of type `{type.FullName}`, received <null> instead." +
+                $"""
-                Environment.NewLine +
+                Failed to create an instance of type `{type.FullName}`, received <null> instead.
-                "To fix this, ensure that the provided type activator is configured correctly, as it's not expected to return <null>." +
+                To fix this, ensure that the provided type activator is configured correctly, as it's not expected to return <null>.
-                Environment.NewLine +
+                If you are relying on a dependency container, this error may indicate that the specified type has not been registered.
-                "If you are relying on a dependency container, this error may indicate that the specified type has not been registered."
+                """
             );
         }
 

CliFx/Infrastructure/FakeConsole.cs

@@ -6,7 +6,7 @@ using System.Threading;
 namespace CliFx.Infrastructure;
 
 /// <summary>
-/// Implementation of <see cref="IConsole"/> that uses the provided fake
+/// Implementation of <see cref="IConsole" /> that uses the provided fake
 /// standard input, output, and error streams.
 /// </summary>
 /// <remarks>
@@ -54,7 +54,7 @@ public class FakeConsole : IConsole, IDisposable
     public int CursorTop { get; set; }
 
     /// <summary>
-    /// Initializes an instance of <see cref="FakeConsole"/>.
+    /// Initializes an instance of <see cref="FakeConsole" />.
     /// </summary>
     public FakeConsole(Stream? input = null, Stream? output = null, Stream? error = null)
     {
@@ -73,7 +73,7 @@ public class FakeConsole : IConsole, IDisposable
             );
 
     /// <summary>
-    /// Enqueues a simulated key press, which can then be read by calling <see cref="ReadKey"/>.
+    /// Enqueues a simulated key press, which can then be read by calling <see cref="ReadKey" />.
     /// </summary>
     public void EnqueueKey(ConsoleKeyInfo key) => _keys.Enqueue(key);
 
@@ -96,7 +96,7 @@ public class FakeConsole : IConsole, IDisposable
     /// Sends a cancellation signal to the currently executing command.
     /// </summary>
     /// <remarks>
-    /// If the command is not cancellation-aware (i.e. it doesn't call <see cref="IConsole.RegisterCancellationHandler"/>),
+    /// If the command is not cancellation-aware (i.e. it doesn't call <see cref="IConsole.RegisterCancellationHandler" />),
     /// this method will not have any effect.
     /// </remarks>
     public void RequestCancellation(TimeSpan? delay = null)

CliFx/Infrastructure/FakeInMemoryConsole.cs

@@ -3,7 +3,7 @@
 namespace CliFx.Infrastructure;
 
 /// <summary>
-/// Implementation of <see cref="IConsole"/> that uses fake
+/// Implementation of <see cref="IConsole" /> that uses fake
 /// standard input, output, and error streams backed by in-memory stores.
 /// </summary>
 /// <remarks>
@@ -24,7 +24,7 @@ public class FakeInMemoryConsole : FakeConsole
     }
 
     /// <summary>
-    /// Initializes an instance of <see cref="FakeInMemoryConsole"/>.
+    /// Initializes an instance of <see cref="FakeInMemoryConsole" />.
     /// </summary>
     public FakeInMemoryConsole()
         : this(new MemoryStream(), new MemoryStream(), new MemoryStream())

CliFx/Infrastructure/IConsole.cs

@@ -105,12 +105,12 @@ public interface IConsole
 }
 
 /// <summary>
-/// Extensions for <see cref="IConsole"/>.
+/// Extensions for <see cref="IConsole" />.
 /// </summary>
 public static class ConsoleExtensions
 {
     /// <summary>
-    /// Sets the specified foreground color and returns an <see cref="IDisposable"/>
+    /// Sets the specified foreground color and returns an <see cref="IDisposable" />
     /// that will reset the color back to its previous value upon disposal.
     /// </summary>
     public static IDisposable WithForegroundColor(this IConsole console, ConsoleColor foregroundColor)
@@ -122,7 +122,7 @@ public static class ConsoleExtensions
     }
 
     /// <summary>
-    /// Sets the specified background color and returns an <see cref="IDisposable"/>
+    /// Sets the specified background color and returns an <see cref="IDisposable" />
     /// that will reset the color back to its previous value upon disposal.
     /// </summary>
     public static IDisposable WithBackgroundColor(this IConsole console, ConsoleColor backgroundColor)
@@ -134,7 +134,7 @@ public static class ConsoleExtensions
     }
 
     /// <summary>
-    /// Sets the specified foreground and background colors and returns an <see cref="IDisposable"/>
+    /// Sets the specified foreground and background colors and returns an <see cref="IDisposable" />
     /// that will reset the colors back to their previous values upon disposal.
     /// </summary>
     public static IDisposable WithColors(

CliFx/Infrastructure/SystemConsole.cs

@@ -4,7 +4,7 @@ using System.Threading;
 namespace CliFx.Infrastructure;
 
 /// <summary>
-/// Implementation of <see cref="IConsole"/> that represents the real system console.
+/// Implementation of <see cref="IConsole" /> that represents the real system console.
 /// </summary>
 public class SystemConsole : IConsole, IDisposable
 {
@@ -71,7 +71,7 @@ public class SystemConsole : IConsole, IDisposable
     }
 
     /// <summary>
-    /// Initializes an instance of <see cref="SystemConsole"/>.
+    /// Initializes an instance of <see cref="SystemConsole" />.
     /// </summary>
     public SystemConsole()
     {

CliFx/Input/CommandInput.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Text;
 using CliFx.Utils.Extensions;
 
 namespace CliFx.Input;
@@ -154,7 +153,7 @@ internal partial class CommandInput
                 if (!string.IsNullOrWhiteSpace(lastOptionIdentifier))
                     result.Add(new OptionInput(lastOptionIdentifier, lastOptionValues));
 
-                lastOptionIdentifier = argument.Substring(2);
+                lastOptionIdentifier = argument[2..];
                 lastOptionValues = new List<string>();
             }
             // Short name
@@ -162,7 +161,7 @@ internal partial class CommandInput
                      argument.Length > 1 &&
                      char.IsLetter(argument[1]))
             {
-                foreach (var alias in argument.Substring(1))
+                foreach (var alias in argument[1..])
                 {
                     // Flush previous
                     if (!string.IsNullOrWhiteSpace(lastOptionIdentifier))

CliFx/Schema/CommandSchema.cs

@@ -70,8 +70,7 @@ internal partial class CommandSchema
     public static bool IsCommandType(Type type) =>
         type.Implements(typeof(ICommand)) &&
         type.IsDefined(typeof(CommandAttribute)) &&
-        !type.IsAbstract &&
+        type is { IsAbstract: false, IsInterface: false };
-        !type.IsInterface;
 
     public static CommandSchema? TryResolve(Type type)
     {
@@ -88,7 +87,7 @@ internal partial class CommandSchema
             : new[] {OptionSchema.HelpOption};
 
         var properties = type
-            // Get properties directly on command type
+            // Get properties directly on the command type
             .GetProperties()
             // Get non-abstract properties on interfaces (to support default interfaces members)
             .Union(type
@@ -129,15 +128,13 @@ internal partial class CommandSchema
         if (schema is null)
         {
             throw CliFxException.InternalError(
-                $"Type `{type.FullName}` is not a valid command type." +
+                $"""
-                Environment.NewLine +
+                Type `{type.FullName}` is not a valid command type.
-                "In order to be a valid command type, it must:" +
+                In order to be a valid command type, it must:
-                Environment.NewLine +
+                - Implement `{typeof(ICommand).FullName}`
-                $"- Implement `{typeof(ICommand).FullName}`" +
+                - Be annotated with `{typeof(CommandAttribute).FullName}`
-                Environment.NewLine +
+                - Not be an abstract class
-                $"- Be annotated with `{typeof(CommandAttribute).FullName}`" +
+                """
-                Environment.NewLine +
-                "- Not be an abstract class"
             );
         }
 

CliFx/Schema/OptionSchema.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Reflection;
 using System.Text;
 using CliFx.Attributes;
+using CliFx.Utils.Extensions;
 
 namespace CliFx.Schema;
 
@@ -101,6 +102,7 @@ internal partial class OptionSchema
         // The user may mistakenly specify dashes, thinking it's required, so trim them
         var name = attribute.Name?.TrimStart('-').Trim();
         var environmentVariable = attribute.EnvironmentVariable?.Trim();
+        var isRequired = attribute.IsRequired || property.IsRequired();
         var description = attribute.Description?.Trim();
 
         return new OptionSchema(
@@ -108,7 +110,7 @@ internal partial class OptionSchema
             name,
             attribute.ShortName,
             environmentVariable,
-            attribute.IsRequired,
+            isRequired,
             description,
             attribute.Converter,
             attribute.Validators

CliFx/Schema/ParameterSchema.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Reflection;
 using CliFx.Attributes;
+using CliFx.Utils.Extensions;
 
 namespace CliFx.Schema;
 
@@ -53,13 +54,14 @@ internal partial class ParameterSchema
             return null;
 
         var name = attribute.Name?.Trim() ?? property.Name.ToLowerInvariant();
+        var isRequired = attribute.IsRequired || property.IsRequired();
         var description = attribute.Description?.Trim();
 
         return new ParameterSchema(
             new BindablePropertyDescriptor(property),
             attribute.Order,
             name,
-            attribute.IsRequired,
+            isRequired,
             description,
             attribute.Converter,
             attribute.Validators

CliFx/Utils/Extensions/CollectionExtensions.cs

@@ -1,4 +1,5 @@
-using System.Collections;
+using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 
@@ -37,4 +38,14 @@ internal static class CollectionExtensions
         dictionary
             .Cast<DictionaryEntry>()
             .ToDictionary(entry => (TKey) entry.Key, entry => (TValue) entry.Value, comparer);
+
+    public static Array ToNonGenericArray<T>(this IEnumerable<T> source, Type elementType)
+    {
+        var sourceAsCollection = source as ICollection ?? source.ToArray();
+
+        var array = Array.CreateInstance(elementType, sourceAsCollection.Count);
+        sourceAsCollection.CopyTo(array, 0);
+
+        return array;
+    }
 }

CliFx/Utils/Extensions/PropertyExtensions.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Linq;
+using System.Reflection;
+
+namespace CliFx.Utils.Extensions;
+
+internal static class PropertyExtensions
+{
+    public static bool IsRequired(this PropertyInfo propertyInfo) =>
+        // Match attribute by name to avoid depending on .NET 7.0+ and to allow polyfilling
+        propertyInfo.GetCustomAttributes().Any(a =>
+            string.Equals(
+                a.GetType().FullName,
+                "System.Runtime.CompilerServices.RequiredMemberAttribute",
+                StringComparison.Ordinal
+            )
+        );
+}

CliFx/Utils/Extensions/TypeExtensions.cs

@@ -11,7 +11,8 @@ internal static class TypeExtensions
     public static bool Implements(this Type type, Type interfaceType) =>
         type.GetInterfaces().Contains(interfaceType);
 
-    public static Type? TryGetNullableUnderlyingType(this Type type) => Nullable.GetUnderlyingType(type);
+    public static Type? TryGetNullableUnderlyingType(this Type type) =>
+        Nullable.GetUnderlyingType(type);
 
     public static Type? TryGetEnumerableUnderlyingType(this Type type)
     {
@@ -44,16 +45,6 @@ internal static class TypeExtensions
         );
     }
 
-    public static Array ToNonGenericArray<T>(this IEnumerable<T> source, Type elementType)
-    {
-        var sourceAsCollection = source as ICollection ?? source.ToArray();
-
-        var array = Array.CreateInstance(elementType, sourceAsCollection.Count);
-        sourceAsCollection.CopyTo(array, 0);
-
-        return array;
-    }
-
     public static bool IsToStringOverriden(this Type type)
     {
         var toStringMethod = type.GetMethod(nameof(ToString), Type.EmptyTypes);

CliFx/Utils/Polyfills.Collections.cs

@@ -1,26 +0,0 @@
-// ReSharper disable CheckNamespace
-
-#if NETSTANDARD2_0
-using System.Collections.Generic;
-
-internal static class CollectionPolyfills
-{
-    public static void Deconstruct<TKey, TValue>(this KeyValuePair<TKey, TValue> pair, out TKey key, out TValue value)
-    {
-        key = pair.Key;
-        value = pair.Value;
-    }
-
-    public static TValue GetValueOrDefault<TKey, TValue>(this IReadOnlyDictionary<TKey, TValue> dic, TKey key) =>
-        dic.TryGetValue(key!, out var result) ? result! : default!;
-}
-
-namespace System.Linq
-{
-    internal static class LinqPolyfills
-    {
-        public static HashSet<T> ToHashSet<T>(this IEnumerable<T> source, IEqualityComparer<T> comparer) =>
-            new(source, comparer);
-    }
-}
-#endif