Update version

Closes #132

.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,3 +1,21 @@
+### v2.3.1 (08-Dec-2022)
+
+- Added support for the `required` keyword introduced in C# 11. Command options bound to required properties are now marked as required by default (equivalent to setting `IsRequired = true` on the attribute). Also added analyzers that prevent marking an option or parameter non-required if it's bound to a required property.
+
+### v2.3 (12-Jul-2022)
+
+- Added console dimension properties `WindowWidth` and `WindowHeight` to `IConsole` interface and implementing classes.
+- Improved inline documentation for members of `IConsole` interface.
+
+### v2.2.6 (14-Jun-2022)
+
+- Added an overload of `CliApplicationBuilder.UseTypeActivator(...)` that accepts an instance of `IServiceProvider`. This slightly simplifies integration with many DI containers.
+- Fixed minor grammar mistakes in user-facing error messages.
+
+### v2.2.5 (10-May-2022)
+
+- Updated default value resolution for the application executable name. It will now resolve to `myapp.exe` instead of `dotnet myapp.dll` when the application is launched through the EXE apphost on Windows. On other platforms, or when running the application through the .NET CLI, the behavior will be the same as before.
+
 ### v2.2.4 (22-Apr-2022)
 
 - Added more contextual information to analyzer diagnostics.

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="GitHubActionsTestLogger" Version="1.4.1" PrivateAssets="all" />
-    <PackageReference Include="FluentAssertions" Version="6.6.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.1.0" />
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.1.0" />
-    <PackageReference Include="xunit" Version="2.4.1" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3" PrivateAssets="all" />
-    <PackageReference Include="coverlet.collector" Version="3.1.2" PrivateAssets="all" />
+    <PackageReference Include="Basic.Reference.Assemblies.Net70" Version="1.4.1" />
+    <PackageReference Include="GitHubActionsTestLogger" Version="2.0.1" PrivateAssets="all" />
+    <PackageReference Include="FluentAssertions" Version="6.8.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.4.0" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.4.0" />
+    <PackageReference Include="xunit" Version="2.4.2" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5" PrivateAssets="all" />
+    <PackageReference Include="coverlet.collector" Version="3.2.0" PrivateAssets="all" />
   </ItemGroup>
 
   <ItemGroup>

CliFx.Analyzers.Tests/CommandMustBeAnnotatedAnalyzerSpecs.cs

@@ -13,11 +13,13 @@ public class CommandMustBeAnnotatedAnalyzerSpecs
     {
         // Arrange
         // language=cs
-        const string code = @"
-public class MyCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        const string code =
+            """
+            public class MyCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -28,12 +30,14 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public abstract class MyCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        const string code =
+            """
+            [Command]
+            public abstract class MyCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -44,11 +48,13 @@ public abstract class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-public abstract class MyCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        const string code =
+            """
+            public abstract class MyCommand : ICommand
+            {
+                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 = @"
-public class Foo
-{
-    public int Bar { get; set; } = 5;
-}";
+        const string code =
+            """
+            public class Foo
+            {
+                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 = @"
-[Command]
-public class MyCommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        const string code =
+            """
+            [Command]
+            public class MyCommand
+            {
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -29,12 +31,14 @@ public class MyCommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                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 = @"
-public class Foo
-{
-    public int Bar { get; set; } = 5;
-}";
+        const string code =
+            """
+            public class Foo
+            {
+                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 = @"
-public class MyClass
-{
-    [CommandOption(""foo"")]
-    public string Foo { get; set; }
-}";
+        const string code =
+            """
+            public class MyClass
+            {
+                [CommandOption("foo")]
+                public string Foo { get; set; }
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -29,15 +31,17 @@ public class MyClass
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption(""foo"")]
-    public string Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [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 = @"
-public abstract class MyCommand
-{
-    [CommandOption(""foo"")]
-    public string Foo { get; set; }
-}";
+        const string code =
+            """
+            public abstract class MyCommand
+            {
+                [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 = @"
-[Command]
-public class MyCommand : ICommand
-{
-    public string Foo { get; set; }
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                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 = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption(null)]
-    public string Foo { get; set; }
-
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption(null)]
+                public string Foo { get; set; }
+            
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().ProduceDiagnostics(code);
@@ -32,15 +34,17 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption(""foo"")]
-    public string Foo { get; set; }
-
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption("foo")]
+                public string Foo { get; set; }
+            
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -51,15 +55,17 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    [CommandOption('f')]
-    public string Foo { get; set; }
-
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                [CommandOption('f')]
+                public string Foo { get; set; }
+            
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);
@@ -70,14 +76,16 @@ public class MyCommand : ICommand
     {
         // Arrange
         // language=cs
-        const string code = @"
-[Command]
-public class MyCommand : ICommand
-{
-    public string Foo { get; set; }
-
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}";
+        const string code =
+            """
+            [Command]
+            public class MyCommand : ICommand
+            {
+                public string Foo { get; set; }
+            
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """;
 
         // Act & assert
         Analyzer.Should().NotProduceDiagnostics(code);

CliFx.Analyzers.Tests/OptionMustHaveUniqueNameAnalyzerSpecs.cs

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

CliFx.Analyzers.Tests/OptionMustHaveUniqueShortNameAnalyzerSpecs.cs

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

CliFx.Analyzers.Tests/OptionMustHaveValidConverterAnalyzerSpecs.cs

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

CliFx.Analyzers.Tests/OptionMustHaveValidNameAnalyzerSpecs.cs

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

CliFx.Analyzers.Tests/OptionMustHaveValidShortNameAnalyzerSpecs.cs

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

CliFx.Analyzers.Tests/OptionMustHaveValidValidatorsAnalyzerSpecs.cs

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

CliFx.Analyzers.Tests/ParameterMustBeInsideCommandAnalyzerSpecs.cs

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

CliFx.Analyzers.Tests/ParameterMustBeLastIfNonRequiredAnalyzerSpecs.cs

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

CliFx.Analyzers.Tests/ParameterMustBeLastIfNonScalarAnalyzerSpecs.cs

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

CliFx.Analyzers.Tests/ParameterMustBeRequiredIfPropertyRequiredAnalyzerSpecs.cs

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

CliFx.Analyzers.Tests/ParameterMustBeSingleIfNonRequiredAnalyzerSpecs.cs

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

CliFx.Analyzers.Tests/ParameterMustBeSingleIfNonScalarAnalyzerSpecs.cs

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

CliFx.Analyzers.Tests/ParameterMustHaveUniqueNameAnalyzerSpecs.cs

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

CliFx.Analyzers.Tests/ParameterMustHaveUniqueOrderAnalyzerSpecs.cs

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

CliFx.Analyzers.Tests/ParameterMustHaveValidConverterAnalyzerSpecs.cs

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

CliFx.Analyzers.Tests/ParameterMustHaveValidValidatorsAnalyzerSpecs.cs

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

CliFx.Analyzers.Tests/SystemConsoleShouldBeAvoidedAnalyzerSpecs.cs

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

CliFx.Analyzers.Tests/Utils/AnalyzerAssertions.cs

@@ -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 +
-                string.Join(Environment.NewLine, compilationErrors.Select(e => e.ToString()))
+                $"""
+                Failed to compile code.
+                {string.Join(Environment.NewLine, compilationErrors.Select(e => e.ToString()))}
+                """
             );
         }
 

CliFx.Analyzers/CliFx.Analyzers.csproj

@@ -3,14 +3,20 @@
   <PropertyGroup>
     <TargetFramework>netstandard2.0</TargetFramework>
     <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
-    <Nullable>annotations</Nullable>
+    <GenerateDependencyFile>true</GenerateDependencyFile>
     <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 -->
-    <!-- https://github.com/Tyrrrz/CliFx/issues/127 -->
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="3.8.0" PrivateAssets="all" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.4.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/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.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.2" />
     <PackageReference Include="clipr" Version="1.6.1" />
-    <PackageReference Include="Cocona" Version="2.0.3" />
-    <PackageReference Include="CommandLineParser" Version="2.8.0" />
-    <PackageReference Include="McMaster.Extensions.CommandLineUtils" Version="4.0.1" />
-    <PackageReference Include="PowerArgs" Version="3.6.0" />
+    <PackageReference Include="Cocona" Version="2.1.0" />
+    <PackageReference Include="CommandLineParser" Version="2.9.1" />
+    <PackageReference Include="McMaster.Extensions.CommandLineUtils" Version="4.0.2" />
+    <PackageReference Include="PowerArgs" Version="4.0.0" />
     <PackageReference Include="System.CommandLine" Version="2.0.0-beta1.20574.7" />
   </ItemGroup>
 

CliFx.Demo/CliFx.Demo.csproj

@@ -2,12 +2,12 @@
 
   <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="Newtonsoft.Json" Version="13.0.1" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="7.0.0" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.2" />
   </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/Readme.md

@@ -2,4 +2,4 @@
 
 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/CancellationSpecs.cs

@@ -21,28 +21,30 @@ public class CancellationSpecs : SpecsBase
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    public async ValueTask ExecuteAsync(IConsole console)
-    {
-        try
-        {
-            await Task.Delay(
-                TimeSpan.FromSeconds(3),
-                console.RegisterCancellationHandler()
-            );
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                public async ValueTask ExecuteAsync(IConsole console)
+                {
+                    try
+                    {
+                        await Task.Delay(
+                            TimeSpan.FromSeconds(3),
+                            console.RegisterCancellationHandler()
+                        );
 
-            console.Output.WriteLine(""Completed successfully"");
-        }
-        catch (OperationCanceledException)
-        {
-            console.Output.WriteLine(""Cancelled"");
-            throw;
-        }
-    }
-}");
+                        console.Output.WriteLine("Completed successfully");
+                    }
+                    catch (OperationCanceledException)
+                    {
+                        console.Output.WriteLine("Cancelled");
+                        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,15 +9,16 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Basic.Reference.Assemblies" Version="1.2.4" />
-    <PackageReference Include="CliWrap" Version="3.4.3" />
-    <PackageReference Include="FluentAssertions" Version="6.6.0" />
-    <PackageReference Include="GitHubActionsTestLogger" Version="1.4.1" PrivateAssets="all" />
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.1.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.1.0" />
-    <PackageReference Include="xunit" Version="2.4.1" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3" PrivateAssets="all" />
-    <PackageReference Include="coverlet.collector" Version="3.1.2" PrivateAssets="all" />
+    <PackageReference Include="Basic.Reference.Assemblies.Net70" Version="1.4.1" />
+    <PackageReference Include="CliWrap" Version="3.5.0" />
+    <PackageReference Include="FluentAssertions" Version="6.8.0" />
+    <PackageReference Include="GitHubActionsTestLogger" Version="2.0.1" PrivateAssets="all" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.4.0" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="7.0.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.4.0" />
+    <PackageReference Include="xunit" Version="2.4.2" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5" PrivateAssets="all" />
+    <PackageReference Include="coverlet.collector" Version="3.2.0" PrivateAssets="all" />
   </ItemGroup>
 
   <ItemGroup>
@@ -25,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

@@ -31,7 +31,8 @@ public class ConsoleSpecs : SpecsBase
         var command = "Hello world" | Cli.Wrap("dotnet")
             .WithArguments(a => a
                 .Add(Dummy.Program.Location)
-                .Add("console-test"));
+                .Add("console-test")
+            );
 
         // Act
         var result = await command.ExecuteBufferedAsync();
@@ -47,25 +48,28 @@ public class ConsoleSpecs : SpecsBase
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{   
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.ResetColor();
-        console.ForegroundColor = ConsoleColor.DarkMagenta;
-        console.BackgroundColor = ConsoleColor.DarkMagenta;
-        console.CursorLeft = 42;
-        console.CursorTop = 24;
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.ResetColor();
+                    console.ForegroundColor = ConsoleColor.DarkMagenta;
+                    console.BackgroundColor = ConsoleColor.DarkMagenta;
+                    console.WindowWidth = 100;
+                    console.WindowHeight = 25;
+                    console.CursorLeft = 42;
+                    console.CursorTop = 24;
 
-        console.Output.WriteLine(""Hello "");
-        console.Error.WriteLine(""world!"");
+                    console.Output.WriteLine("Hello ");
+                    console.Error.WriteLine("world!");
 
-        return default;
-    }
-}
-");
+                    return default;
+                }
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -89,6 +93,8 @@ public class Command : ICommand
         Console.BackgroundColor.Should().NotBe(ConsoleColor.DarkMagenta);
 
         // This fails because tests don't spawn a console window
+        //Console.WindowWidth.Should().Be(100);
+        //Console.WindowHeight.Should().Be(25);
         //Console.CursorLeft.Should().NotBe(42);
         //Console.CursorTop.Should().NotBe(24);
 
@@ -103,20 +109,21 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{   
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        var input = console.Input.ReadToEnd();
-        console.Output.WriteLine(input);
-        console.Error.WriteLine(input);
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    var input = console.Input.ReadToEnd();
+                    console.Output.WriteLine(input);
+                    console.Error.WriteLine(input);
 
-        return default;
-    }
-}
-");
+                    return default;
+                }
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -146,20 +153,21 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{   
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(console.ReadKey().Key);
-        console.Output.WriteLine(console.ReadKey().Key);
-        console.Output.WriteLine(console.ReadKey().Key);
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine(console.ReadKey().Key);
+                    console.Output.WriteLine(console.ReadKey().Key);
+                    console.Output.WriteLine(console.ReadKey().Key);
 
-        return default;
-    }
-}
-");
+                    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]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public string Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                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]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public object Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                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]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public bool Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                public bool Foo { get; set; }
 
-    [CommandOption('b')]
-    public bool Bar { get; set; }
+                [CommandOption('b')]
+                public bool Bar { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""Foo = "" + Foo);
-        console.Output.WriteLine(""Bar = "" + Bar);
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("Foo = " + Foo);
+                    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]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public bool Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                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]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public int Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                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]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public double Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                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]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public DateTimeOffset Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                public DateTimeOffset Foo { get; set; }
+
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine(Foo.ToString("u", CultureInfo.InvariantCulture));
+                    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]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public TimeSpan Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                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]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public CustomEnum Foo { get; set; }
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                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]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public int? Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                public int? Foo { get; set; }
 
-    [CommandOption('b')]
-    public int? Bar { get; set; }
+                [CommandOption('b')]
+                public int? Bar { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""Foo = "" + Foo);
-        console.Output.WriteLine(""Bar = "" + Bar);
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("Foo = " + Foo);
+                    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]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public CustomEnum? Foo { get; set; }
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                public CustomEnum? Foo { get; set; }
 
-    [CommandOption('b')]
-    public CustomEnum? Bar { get; set; }
+                [CommandOption('b')]
+                public CustomEnum? Bar { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""Foo = "" + (int?) Foo);
-        console.Output.WriteLine(""Bar = "" + (int?) Bar);
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("Foo = " + (int?) Foo);
+                    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 string Value { get; }
+            """
+            public class CustomType
+            {
+                public string Value { get; }
 
-    public CustomType(string value) => Value = value;
-}
+                public CustomType(string value) => Value = value;
+            }
 
-[Command]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public CustomType Foo { get; set; }
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                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 string Value { get; }
+            """
+            public class CustomTypeA
+            {
+                public string Value { get; }
 
-    private CustomTypeA(string value) => Value = value;
+                private CustomTypeA(string value) => Value = value;
 
-    public static CustomTypeA Parse(string value) => 
-        new CustomTypeA(value);
-}
+                public static CustomTypeA Parse(string value) =>
+                    new CustomTypeA(value);
+            }
 
-public class CustomTypeB
-{
-    public string Value { get; }
+            public class CustomTypeB
+            {
+                public string Value { get; }
 
-    private CustomTypeB(string value) => Value = value;
+                private CustomTypeB(string value) => Value = value;
 
-    public static CustomTypeB Parse(string value, IFormatProvider formatProvider) =>
-        new CustomTypeB(value);
-}
+                public static CustomTypeB Parse(string value, IFormatProvider formatProvider) =>
+                    new CustomTypeB(value);
+            }
 
-[Command]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public CustomTypeA Foo { get; set; }
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                public CustomTypeA Foo { get; set; }
 
-    [CommandOption('b')]
-    public CustomTypeB Bar { get; set; }
+                [CommandOption('b')]
+                public CustomTypeB Bar { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""Foo = "" + Foo.Value);
-        console.Output.WriteLine(""Bar = "" + Bar.Value);
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("Foo = " + Foo.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 override int Convert(string rawValue) =>
-        rawValue.Length;
-}
+            """
+            public class CustomConverter : BindingConverter<int>
+            {
+                public override int Convert(string rawValue) =>
+                    rawValue.Length;
+            }
 
-[Command]
-public class Command : ICommand
-{
-    [CommandOption('f', Converter = typeof(CustomConverter))]
-    public int Foo { get; set; }
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f', Converter = typeof(CustomConverter))]
+                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]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public string[] Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                public string[] Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        foreach (var i in Foo)
-            console.Output.WriteLine(i);
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    foreach (var i in Foo)
+                        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]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public IReadOnlyList<string> Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                public IReadOnlyList<string> Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        foreach (var i in Foo)
-            console.Output.WriteLine(i);
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    foreach (var i in Foo)
+                        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]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public List<string> Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                public List<string> Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        foreach (var i in Foo)
-            console.Output.WriteLine(i);
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    foreach (var i in Foo)
+                        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]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public int[] Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                public int[] Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        foreach (var i in Foo)
-            console.Output.WriteLine(i);
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    foreach (var i in Foo)
+                        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]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public int Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                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]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public CustomType Foo { get; set; }
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                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 IEnumerator<object> GetEnumerator() => Enumerable.Empty<object>().GetEnumerator();
+            """
+            public class CustomType : IEnumerable<object>
+            {
+                public IEnumerator<object> GetEnumerator() => Enumerable.Empty<object>().GetEnumerator();
 
-    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
-}
+                IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+            }
 
-[Command]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public CustomType Foo { get; set; }
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                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 override BindingValidationError Validate(int value) => Ok();
-}
+            """
+            public class ValidatorA : BindingValidator<int>
+            {
+                public override BindingValidationError Validate(int value) => Ok();
+            }
 
-public class ValidatorB : BindingValidator<int>
-{
-    public override BindingValidationError Validate(int value) => Error(""Hello world"");
-}
+            public class ValidatorB : BindingValidator<int>
+            {
+                public override BindingValidationError Validate(int value) => Error("Hello world");
+            }
 
-[Command]
-public class Command : ICommand
-{
-    [CommandOption('f', Validators = new[] {typeof(ValidatorA), typeof(ValidatorB)})]
-    public int Foo { get; set; }
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f', Validators = new[] {typeof(ValidatorA), typeof(ValidatorB)})]
+                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 string Value { get; }
+            """
+            public class CustomType
+            {
+                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]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public CustomType Foo { get; set; }
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                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

@@ -28,7 +28,8 @@ public class DirectivesSpecs : SpecsBase
         var command = Cli.Wrap("dotnet")
             .WithArguments(a => a
                 .Add(Dummy.Program.Location)
-                .Add("[debug]")) | stdOutBuffer;
+                .Add("[debug]")
+            ) | stdOutBuffer;
 
         // Act
         try
@@ -57,7 +58,7 @@ public class DirectivesSpecs : SpecsBase
         }
         catch (OperationCanceledException)
         {
-            // It's expected to fail
+            // This is expected
         }
 
         var stdOut = stdOutBuffer.ToString();
@@ -74,13 +75,14 @@ public class DirectivesSpecs : SpecsBase
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command(""cmd"")]
-public class Command : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+            """
+            [Command("cmd")]
+            public class Command : ICommand
+            {
+                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]
-public class Command : ICommand
-{
-    [CommandOption(""foo"", IsRequired = true, EnvironmentVariable = ""ENV_FOO"")]
-    public string Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo", IsRequired = true, EnvironmentVariable = "ENV_FOO")]
+                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)
@@ -67,20 +68,21 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""foo"", EnvironmentVariable = ""ENV_FOO"")]
-    public string Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo", EnvironmentVariable = "ENV_FOO")]
+                public string Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(Foo);
-        return default;
-    }
-}
-");
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine(Foo);
+                    return default;
+                }
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -109,22 +111,23 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""foo"", EnvironmentVariable = ""ENV_FOO"")]
-    public IReadOnlyList<string> Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo", EnvironmentVariable = "ENV_FOO")]
+                public IReadOnlyList<string> Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        foreach (var i in Foo)
-            console.Output.WriteLine(i);
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    foreach (var i in Foo)
+                        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]
-public class Command : ICommand
-{
-    [CommandOption(""foo"", EnvironmentVariable = ""ENV_FOO"")]
-    public string Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo", EnvironmentVariable = "ENV_FOO")]
+                public string Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(Foo);
-        return default;
-    }
-}
-");
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine(Foo);
+                    return default;
+                }
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -198,20 +202,21 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""foo"", EnvironmentVariable = ""ENV_FOO"")]
-    public string Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo", EnvironmentVariable = "ENV_FOO")]
+                public string Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(Foo);
-        return default;
-    }
-}
-");
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine(Foo);
+                    return default;
+                }
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -246,9 +251,11 @@ public class Command : ICommand
         var command = Cli.Wrap("dotnet")
             .WithArguments(a => a
                 .Add(Dummy.Program.Location)
-                .Add("env-test"))
+                .Add("env-test")
+            )
             .WithEnvironmentVariables(e => e
-                .Set("ENV_TARGET", "Mars"));
+                .Set("ENV_TARGET", "Mars")
+            );
 
         // Act
         var result = await command.ExecuteBufferedAsync();

CliFx.Tests/ErrorReportingSpecs.cs

@@ -22,14 +22,15 @@ public class ErrorReportingSpecs : SpecsBase
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) =>
-        throw new Exception(""Something went wrong"");
-}
-");
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console) =>
+                    throw new Exception("Something went wrong");
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -60,14 +61,15 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) =>
-        throw new Exception(""Something went wrong"", new Exception(""Another exception""));
-}
-");
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console) =>
+                    throw new Exception("Something went wrong", new Exception("Another exception"));
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -99,14 +101,15 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) =>
-        throw new CommandException(""Something went wrong"", 69);
-}
-");
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console) =>
+                    throw new CommandException("Something went wrong", 69);
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -134,14 +137,15 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) =>
-        throw new CommandException("""", 69);
-}
-");
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console) =>
+                    throw new CommandException("", 69);
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -172,14 +176,15 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) =>
-        throw new CommandException(""Something went wrong"", 69, true);
-}
-");
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console) =>
+                    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]
-public class DefaultCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+            """
+            [Command]
+            public class DefaultCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -77,19 +78,20 @@ public class DefaultCommand : ICommand
         // Arrange
         var commandTypes = DynamicCommandBuilder.CompileMany(
             // language=cs
-            @"
-[Command(""cmd"")]
-public class NamedCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
+            """
+            [Command("cmd")]
+            public class NamedCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
 
-[Command(""cmd child"")]
-public class NamedChildCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+            [Command("cmd child")]
+            public class NamedChildCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommands(commandTypes)
@@ -116,25 +118,26 @@ public class NamedChildCommand : ICommand
         // Arrange
         var commandTypes = DynamicCommandBuilder.CompileMany(
             // language=cs
-            @"
-[Command]
-public class DefaultCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
+            """
+            [Command]
+            public class DefaultCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
 
-[Command(""cmd"", Description = ""Description of a named command."")]
-public class NamedCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
+            [Command("cmd", Description = "Description of a named command.")]
+            public class NamedCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
 
-[Command(""cmd child"")]
-public class NamedChildCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+            [Command("cmd child")]
+            public class NamedChildCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommands(commandTypes)
@@ -160,25 +163,26 @@ public class NamedChildCommand : ICommand
         // Arrange
         var commandTypes = DynamicCommandBuilder.CompileMany(
             // language=cs
-            @"
-[Command]
-public class DefaultCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
+            """
+            [Command]
+            public class DefaultCommand : ICommand
+            {
+                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;
+            }
 
-[Command(""cmd child"", Description = ""Description of a named child command."")]
-public class NamedChildCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+            [Command("cmd child", Description = "Description of a named child command.")]
+            public class NamedChildCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommands(commandTypes)
@@ -257,13 +261,15 @@ public class NamedChildCommand : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command(Description = ""Description of the default command."")]
-public class DefaultCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+            """
+                
+                [Command(Description = "Description of the default command.")]
+                public class DefaultCommand : ICommand
+                {
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
+
+                """);
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -292,19 +298,21 @@ public class DefaultCommand : ICommand
         // Arrange
         var commandTypes = DynamicCommandBuilder.CompileMany(
             // language=cs
-            @"
-[Command]
-public class DefaultCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
+            """
+                
+                [Command]
+                public class DefaultCommand : ICommand
+                {
+                    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
-{
-    [CommandParameter(0)]
-    public string Foo { get; set; }
+            """
+                
+                [Command]
+                public class Command : ICommand
+                {
+                    [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
-{
-    [CommandParameter(0)]
-    public string Foo { get; set; }
+            """
+                
+                // Base members appear last in reflection order
+                public abstract class CommandBase : ICommand
+                {
+                    [CommandParameter(0)]
+                    public string Foo { get; set; }
+                
+                    public abstract ValueTask ExecuteAsync(IConsole console);
+                }
+                
+                [Command]
+                public class Command : CommandBase
+                {
+                    [CommandParameter(2)]
+                    public IReadOnlyList<string> Baz { get; set; }
+                
+                    [CommandParameter(1)]
+                    public string Bar { get; set; }
+                
+                    public override ValueTask ExecuteAsync(IConsole console) => default;
+                }
 
-    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
-{
-    [CommandOption(""foo"", IsRequired = true)]
-    public string Foo { get; set; }
+            """
+                
+                [Command]
+                public class Command : ICommand
+                {
+                    [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
-{
-    [CommandParameter(0, Name = ""foo"", Description = ""Description of foo."")]
-    public string Foo { get; set; }
+            """
+                
+                [Command]
+                public class Command : ICommand
+                {
+                    [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
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+            """
+                
+                [Command]
+                public class Command : ICommand
+                {
+                    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
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
-");
+            """
+                
+                [Command("cmd")]
+                public class Command : ICommand
+                {
+                    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
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
+            """
+                
+                [Command("cmd1", Description = "Description of one command.")]
+                public class FirstCommand : ICommand
+                {
+                    public ValueTask ExecuteAsync(IConsole console) => default;
+                }
+                
+                [Command("cmd2", Description = "Description of another command.")]
+                public class SecondCommand : ICommand
+                {
+                    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
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
+            """
+                
+                [Command("cmd1")]
+                public class FirstCommand : 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;
+                }
 
-[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
-{
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}
+            """
+                
+                [Command("cmd1")]
+                public class FirstCommand : 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;
+                }
 
-[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]
-public class Command : ICommand
-{
-    [CommandOption(""foo"")]
-    public bool Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo")]
+                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)
@@ -60,19 +62,21 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public bool Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                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)
@@ -98,24 +102,26 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandOption(""foo"")]
-    public string Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [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)
-    {
-        console.Output.WriteLine(""Foo = "" + Foo);
-        console.Output.WriteLine(""Bar = "" + Bar);
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("Foo = " + Foo);
+                    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]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public string Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [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)
-    {
-        console.Output.WriteLine(""Foo = "" + Foo);
-        console.Output.WriteLine(""Bar = "" + Bar);
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("Foo = " + Foo);
+                    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]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public string Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [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)
-    {
-        console.Output.WriteLine(""Foo = "" + Foo);
-        console.Output.WriteLine(""Bar = "" + Bar);
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("Foo = " + Foo);
+                    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]
-public class Command : ICommand
-{
-    [CommandOption(""Foo"")]
-    public IReadOnlyList<string> Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("Foo")]
+                public IReadOnlyList<string> Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        foreach (var i in Foo)
-            console.Output.WriteLine(i);
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    foreach (var i in Foo)
+                        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]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public IReadOnlyList<string> Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                public IReadOnlyList<string> Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        foreach (var i in Foo)
-            console.Output.WriteLine(i);
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    foreach (var i in Foo)
+                        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]
-public class Command : ICommand
-{
-    [CommandOption(""foo"")]
-    public IReadOnlyList<string> Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo")]
+                public IReadOnlyList<string> Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        foreach (var i in Foo)
-            console.Output.WriteLine(i);
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    foreach (var i in Foo)
+                        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]
-public class Command : ICommand
-{
-    [CommandOption('f')]
-    public IReadOnlyList<string> Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption('f')]
+                public IReadOnlyList<string> Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        foreach (var i in Foo)
-            console.Output.WriteLine(i);
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    foreach (var i in Foo)
+                        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]
-public class Command : ICommand
-{
-    [CommandOption(""foo"", 'f')]
-    public IReadOnlyList<string> Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo", 'f')]
+                public IReadOnlyList<string> Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        foreach (var i in Foo)
-            console.Output.WriteLine(i);
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    foreach (var i in Foo)
+                        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]
-public class Command : ICommand
-{
-    [CommandOption(""foo"")]
-    public string Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo")]
+                public string Foo { get; set; }
 
-    [CommandOption(""bar"")]
-    public string Bar { get; set; } = ""hello"";
+                [CommandOption("bar")]
+                public string Bar { get; set; } = "hello";
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""Foo = "" + Foo);
-        console.Output.WriteLine(""Bar = "" + Bar);
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("Foo = " + Foo);
+                    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 int Foo { get; set; }
+            """
+            public static class SharedContext
+            {
+                public static int Foo { get; set; }
 
-    public static bool Bar { get; set; }
-}
+                public static bool Bar { get; set; }
+            }
 
-public interface IHasFoo : ICommand
-{
-    [CommandOption(""foo"")]
-    public int Foo
-    {
-        get => SharedContext.Foo;
-        set => SharedContext.Foo = value;
-    }
-}
+            public interface IHasFoo : ICommand
+            {
+                [CommandOption("foo")]
+                public int Foo
+                {
+                    get => SharedContext.Foo;
+                    set => SharedContext.Foo = value;
+                }
+            }
 
-public interface IHasBar : ICommand
-{
-    [CommandOption(""bar"")]
-    public bool Bar
-    {
-        get => SharedContext.Bar;
-        set => SharedContext.Bar = value;
-    }
-}
+            public interface IHasBar : ICommand
+            {
+                [CommandOption("bar")]
+                public bool Bar
+                {
+                    get => SharedContext.Bar;
+                    set => SharedContext.Bar = value;
+                }
+            }
 
-public interface IHasBaz : ICommand
-{
-    public string Baz { get; set; }
-}
+            public interface IHasBaz : ICommand
+            {
+                public string Baz { get; set; }
+            }
 
-[Command]
-public class Command : IHasFoo, IHasBar, IHasBaz
-{
-    [CommandOption(""baz"")]
-    public string Baz { get; set; }
+            [Command]
+            public class Command : IHasFoo, IHasBar, IHasBaz
+            {
+                [CommandOption("baz")]
+                public string Baz { get; set; }
 
-	public ValueTask ExecuteAsync(IConsole console)
-	{
-        console.Output.WriteLine(""Foo = "" + SharedContext.Foo);
-        console.Output.WriteLine(""Bar = "" + SharedContext.Bar);
-        console.Output.WriteLine(""Baz = "" + Baz);
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("Foo = " + SharedContext.Foo);
+                    console.Output.WriteLine("Bar = " + SharedContext.Bar);
+                    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]
-public class Command : ICommand
-{
-    [CommandOption(""foo"")]
-    public string Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo")]
+                public string Foo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(Foo);
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    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]
-public class Command : ICommand
-{
-    [CommandOption(""foo"", IsRequired = true)]
-    public string Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo", IsRequired = true)]
+                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]
-public class Command : ICommand
-{
-    [CommandOption(""foo"", IsRequired = true)]
-    public string Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo", IsRequired = true)]
+                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]
-public class Command : ICommand
-{
-    [CommandOption(""foo"", IsRequired = true)]
-    public IReadOnlyList<string> Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo", IsRequired = true)]
+                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]
-public class Command : ICommand
-{
-    [CommandOption(""foo"")]
-    public string Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo")]
+                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]
-public class Command : ICommand
-{
-    [CommandOption(""foo"")]
-    public string Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandOption("foo")]
+                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]
-public class Command : ICommand
-{
-    [CommandParameter(0)]
-    public string Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [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)
-    {
-        console.Output.WriteLine(""Foo = "" + Foo);
-        console.Output.WriteLine(""Bar = "" + Bar);
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("Foo = " + Foo);
+                    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]
-public class Command : ICommand
-{
-    [CommandParameter(0)]
-    public string Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandParameter(0)]
+                public string Foo { get; set; }
 
-    [CommandParameter(1)]
-    public string Bar { get; set; }
+                [CommandParameter(1)]
+                public string Bar { get; set; }
 
-    [CommandParameter(2)]
-    public IReadOnlyList<string> Baz { get; set; }
+                [CommandParameter(2)]
+                public IReadOnlyList<string> Baz { get; set; }
 
-    [CommandOption(""boo"")]
-    public string Boo { get; set; }
+                [CommandOption("boo")]
+                public string Boo { get; set; }
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""Foo = "" + Foo);
-        console.Output.WriteLine(""Bar = "" + Bar);
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("Foo = " + Foo);
+                    console.Output.WriteLine("Bar = " + Bar);
 
-        foreach (var i in Baz)
-            console.Output.WriteLine(""Baz = "" + i);
+                    foreach (var i in Baz)
+                        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]
-public class Command : ICommand
-{
-    [CommandParameter(0)]
-    public string Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandParameter(0)]
+                public string Foo { get; set; }
 
-    [CommandParameter(1, IsRequired = false)]
-    public string Bar { get; set; } = ""xyz"";
+                [CommandParameter(1, IsRequired = false)]
+                public string Bar { get; set; } = "xyz";
 
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""Foo = "" + Foo);
-        console.Output.WriteLine(""Bar = "" + Bar);
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("Foo = " + Foo);
+                    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]
-public class Command : ICommand
-{
-    [CommandParameter(0)]
-    public string Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [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;
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -208,18 +216,20 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    [CommandParameter(0)]
-    public string Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [CommandParameter(0)]
+                public string Foo { get; set; }
 
-    [CommandParameter(1)]
-    public IReadOnlyList<string> Bar { get; set; }
+                [CommandParameter(1)]
+                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]
-public class Command : ICommand
-{
-    [CommandParameter(0)]
-    public string Foo { get; set; }
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                [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;
+            }
+            """
+        );
 
         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]
-public class DefaultCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""default"");
-        return default;
-    }
-}
+            """
+            [Command]
+            public class DefaultCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("default");
+                    return default;
+                }
+            }
 
-[Command(""cmd"")]
-public class NamedCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""cmd"");
-        return default;
-    }
-}
+            [Command("cmd")]
+            public class NamedCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("cmd");
+                    return default;
+                }
+            }
 
-[Command(""cmd child"")]
-public class NamedChildCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""cmd child"");
-        return default;
-    }
-}
-");
+            [Command("cmd child")]
+            public class NamedChildCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("cmd child");
+                    return default;
+                }
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommands(commandTypes)
@@ -77,37 +78,38 @@ public class NamedChildCommand : ICommand
         // Arrange
         var commandTypes = DynamicCommandBuilder.CompileMany(
             // language=cs
-            @"
-[Command]
-public class DefaultCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""default"");
-        return default;
-    }
-}
+            """
+            [Command]
+            public class DefaultCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("default");
+                    return default;
+                }
+            }
 
-[Command(""cmd"")]
-public class NamedCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""cmd"");
-        return default;
-    }
-}
+            [Command("cmd")]
+            public class NamedCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("cmd");
+                    return default;
+                }
+            }
 
-[Command(""cmd child"")]
-public class NamedChildCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""cmd child"");
-        return default;
-    }
-}
-");
+            [Command("cmd child")]
+            public class NamedChildCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("cmd child");
+                    return default;
+                }
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommands(commandTypes)
@@ -133,37 +135,38 @@ public class NamedChildCommand : ICommand
         // Arrange
         var commandTypes = DynamicCommandBuilder.CompileMany(
             // language=cs
-            @"
-[Command]
-public class DefaultCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""default"");
-        return default;
-    }
-}
+            """
+            [Command]
+            public class DefaultCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("default");
+                    return default;
+                }
+            }
 
-[Command(""cmd"")]
-public class NamedCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""cmd"");
-        return default;
-    }
-}
+            [Command("cmd")]
+            public class NamedCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("cmd");
+                    return default;
+                }
+            }
 
-[Command(""cmd child"")]
-public class NamedChildCommand : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""cmd child"");
-        return default;
-    }
-}
-");
+            [Command("cmd child")]
+            public class NamedChildCommand : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("cmd child");
+                    return default;
+                }
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommands(commandTypes)

CliFx.Tests/TypeActivationSpecs.cs

@@ -4,6 +4,7 @@ using System.Threading.Tasks;
 using CliFx.Infrastructure;
 using CliFx.Tests.Utils;
 using FluentAssertions;
+using Microsoft.Extensions.DependencyInjection;
 using Xunit;
 using Xunit.Abstractions;
 
@@ -22,16 +23,18 @@ public class TypeActivationSpecs : SpecsBase
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""foo"");
-        return default;
-    }
-}");
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("foo");
+                    return default;
+                }
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -58,14 +61,16 @@ public class Command : ICommand
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    public Command(string foo) {}
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                public Command(string foo) {}
 
-    public ValueTask ExecuteAsync(IConsole console) => default;
-}");
+                public ValueTask ExecuteAsync(IConsole console) => default;
+            }
+            """
+        );
 
         var application = new CliApplicationBuilder()
             .AddCommand(commandType)
@@ -87,30 +92,32 @@ public class Command : ICommand
     }
 
     [Fact]
-    public async Task Delegate_type_activator_can_initialize_a_type_using_a_custom_function()
+    public async Task Custom_type_activator_can_initialize_a_type_using_a_given_function()
     {
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    private readonly string _foo;
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                private readonly string _foo;
 
-    public Command(string foo) => _foo = foo;
+                public Command(string foo) => _foo = foo;
 
-    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)
-            .UseTypeActivator(type => Activator.CreateInstance(type, "hello world")!)
+            .UseTypeActivator(type => Activator.CreateInstance(type, "Hello world")!)
             .Build();
 
         // Act
@@ -123,25 +130,73 @@ public class Command : ICommand
 
         // Assert
         exitCode.Should().Be(0);
-        stdOut.Trim().Should().Be("hello world");
+        stdOut.Trim().Should().Be("Hello world");
     }
 
     [Fact]
-    public async Task Delegate_type_activator_fails_if_the_underlying_function_returns_null()
+    public async Task Custom_type_activator_can_initialize_a_type_using_a_service_provider()
     {
         // Arrange
         var commandType = DynamicCommandBuilder.Compile(
             // language=cs
-            @"
-[Command]
-public class Command : ICommand
-{
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(""foo"");
-        return default;
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                private readonly string _foo;
+
+                public Command(string foo) => _foo = foo;
+
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine(_foo);
+                    return default;
+                }
+            }
+            """
+        );
+
+        var serviceProvider = new ServiceCollection()
+            .AddSingleton(commandType, Activator.CreateInstance(commandType, "Hello world")!)
+            .BuildServiceProvider();
+
+        var application = new CliApplicationBuilder()
+            .AddCommand(commandType)
+            .UseConsole(FakeConsole)
+            .UseTypeActivator(serviceProvider)
+            .Build();
+
+        // Act
+        var exitCode = await application.RunAsync(
+            Array.Empty<string>(),
+            new Dictionary<string, string>()
+        );
+
+        var stdOut = FakeConsole.ReadOutputString();
+
+        // Assert
+        exitCode.Should().Be(0);
+        stdOut.Trim().Should().Be("Hello world");
     }
-}");
+
+    [Fact]
+    public async Task Custom_type_activator_fails_if_the_underlying_function_returns_null()
+    {
+        // Arrange
+        var commandType = DynamicCommandBuilder.Compile(
+            // language=cs
+            """
+            [Command]
+            public class Command : ICommand
+            {
+                public ValueTask ExecuteAsync(IConsole console)
+                {
+                    console.Output.WriteLine("foo");
+                    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 +
-                string.Join(Environment.NewLine, compilationErrors.Select(e => e.ToString()))
+                $"""
+                Failed to compile code.
+                {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 +
-                string.Join(Environment.NewLine, emitErrors.Select(e => e.ToString()))
+                $"""
+                Failed to emit code.
+                {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,6 +32,10 @@ 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>
@@ -51,7 +55,7 @@ public sealed class CommandOptionAttribute : Attribute
     /// 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,7 +78,7 @@ 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)
@@ -82,7 +86,7 @@ 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)
         : this(name, null)
@@ -90,7 +94,7 @@ 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)

CliFx/Attributes/CommandParameterAttribute.cs

@@ -51,7 +51,7 @@ public sealed class CommandParameterAttribute : Attribute
     /// 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

@@ -34,7 +34,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,

CliFx/CliApplicationBuilder.cs

@@ -6,12 +6,13 @@ using System.Reflection;
 using CliFx.Attributes;
 using CliFx.Infrastructure;
 using CliFx.Schema;
+using CliFx.Utils;
 using CliFx.Utils.Extensions;
 
 namespace CliFx;
 
 /// <summary>
-/// Builder for <see cref="CliApplication"/>.
+/// Builder for <see cref="CliApplication" />.
 /// </summary>
 public partial class CliApplicationBuilder
 {
@@ -21,7 +22,7 @@ public partial class CliApplicationBuilder
     private bool _isPreviewModeAllowed = true;
     private string? _title;
     private string? _executableName;
-    private string? _versionText;
+    private string? _version;
     private string? _description;
     private IConsole? _console;
     private ITypeActivator? _typeActivator;
@@ -57,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"/>
-    /// and are annotated by <see cref="CommandAttribute"/>.
+    /// This method looks for public non-abstract classes that implement <see cref="ICommand" />
+    /// and are annotated by <see cref="CommandAttribute" />.
     /// </remarks>
     public CliApplicationBuilder AddCommandsFrom(Assembly commandAssembly)
     {
@@ -72,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"/>
-    /// and are annotated by <see cref="CommandAttribute"/>.
+    /// This method looks for public non-abstract classes that implement <see cref="ICommand" />
+    /// and are annotated by <see cref="CommandAttribute" />.
     /// </remarks>
     public CliApplicationBuilder AddCommandsFrom(IEnumerable<Assembly> commandAssemblies)
     {
@@ -87,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"/>
-    /// and are annotated by <see cref="CommandAttribute"/>.
+    /// This method looks for public non-abstract classes that implement <see cref="ICommand" />
+    /// and are annotated by <see cref="CommandAttribute" />.
     /// </remarks>
     public CliApplicationBuilder AddCommandsFromThisAssembly() => AddCommandsFrom(Assembly.GetCallingAssembly());
 
@@ -144,7 +145,7 @@ public partial class CliApplicationBuilder
     /// </remarks>
     public CliApplicationBuilder SetVersion(string version)
     {
-        _versionText = version;
+        _version = version;
         return this;
     }
 
@@ -158,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)
     {
@@ -167,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)
     {
@@ -182,14 +183,20 @@ public partial class CliApplicationBuilder
         UseTypeActivator(new DelegateTypeActivator(typeActivator));
 
     /// <summary>
-    /// Creates a configured instance of <see cref="CliApplication"/>.
+    /// Configures the application to use the specified service provider for activating types.
+    /// </summary>
+    public CliApplicationBuilder UseTypeActivator(IServiceProvider serviceProvider) =>
+        UseTypeActivator(serviceProvider.GetService);
+
+    /// <summary>
+    /// Creates a configured instance of <see cref="CliApplication" />.
     /// </summary>
     public CliApplication Build()
     {
         var metadata = new ApplicationMetadata(
             _title ?? GetDefaultTitle(),
             _executableName ?? GetDefaultExecutableName(),
-            _versionText ?? GetDefaultVersionText(),
+            _version ?? GetDefaultVersionText(),
             _description
         );
 
@@ -210,14 +217,9 @@ public partial class CliApplicationBuilder
 
 public partial class CliApplicationBuilder
 {
-    private static readonly Lazy<Assembly?> EntryAssemblyLazy = new(Assembly.GetEntryAssembly);
-
-    // Entry assembly can be null, for example in tests
-    private static Assembly? EntryAssembly => EntryAssemblyLazy.Value;
-
     private static string GetDefaultTitle()
     {
-        var entryAssemblyName = EntryAssembly?.GetName().Name;
+        var entryAssemblyName = EnvironmentEx.EntryAssembly?.GetName().Name;
         if (string.IsNullOrWhiteSpace(entryAssemblyName))
             return "App";
 
@@ -226,26 +228,39 @@ public partial class CliApplicationBuilder
 
     private static string GetDefaultExecutableName()
     {
-        var entryAssemblyLocation = EntryAssembly?.Location;
+        var entryAssemblyLocation = EnvironmentEx.EntryAssembly?.Location;
         if (string.IsNullOrWhiteSpace(entryAssemblyLocation))
             return "app";
 
-        // The assembly can be an .exe or a .dll, depending on how it was packaged
+        // If the application was launched via matching EXE apphost, use that as the executable name
+        var isLaunchedViaAppHost = string.Equals(
+            EnvironmentEx.ProcessPath,
+            Path.ChangeExtension(entryAssemblyLocation, ".exe"),
+            StringComparison.OrdinalIgnoreCase
+        );
+
+        if (isLaunchedViaAppHost)
+            return Path.GetFileNameWithoutExtension(entryAssemblyLocation);
+
+        // Otherwise, use the entry assembly as the executable name.
+        // Prefix it with `dotnet` if it's a DLL file.
         var isDll = string.Equals(
             Path.GetExtension(entryAssemblyLocation),
             ".dll",
             StringComparison.OrdinalIgnoreCase
         );
 
-        var name = isDll
+        return isDll
             ? "dotnet " + Path.GetFileName(entryAssemblyLocation)
             : Path.GetFileNameWithoutExtension(entryAssemblyLocation);
-
-        return name;
     }
 
-    private static string GetDefaultVersionText() =>
-        EntryAssembly is not null
-            ? "v" + EntryAssembly.GetName().Version.ToSemanticString()
-            : "v1.0";
+    private static string GetDefaultVersionText()
+    {
+        var entryAssemblyVersion = EnvironmentEx.EntryAssembly?.GetName().Version;
+        if (entryAssemblyVersion is null)
+            return "v1.0";
+
+        return "v" + entryAssemblyVersion.ToSemanticString();
+    }
 }

CliFx/CliFx.csproj

@@ -2,9 +2,12 @@
 
   <PropertyGroup>
     <TargetFrameworks>netstandard2.1;netstandard2.0</TargetFrameworks>
+    <IsPackable>true</IsPackable>
+  </PropertyGroup>
+
+  <PropertyGroup>
     <Authors>$(Company)</Authors>
     <Description>Declarative framework for building command line applications</Description>
-    <IsPackable>true</IsPackable>
     <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>
@@ -24,16 +27,17 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.1.1" PrivateAssets="all" />
-    <PackageReference Include="Nullable" Version="1.3.0" PrivateAssets="all" />
+    <PackageReference Include="Nullable" Version="1.3.1" PrivateAssets="all" />
   </ItemGroup>
 
   <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
     <PackageReference Include="System.Threading.Tasks.Extensions" Version="4.5.4" />
   </ItemGroup>
 
-  <!-- Pack the analyzer assembly inside the package -->
+  <!-- Embed the analyzer 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

@@ -99,11 +99,11 @@ internal class CommandBinder
         }
 
         throw CliFxException.InternalError(
-            $"{memberSchema.GetKind()} {memberSchema.GetFormattedIdentifier()} has an unsupported underlying property type." +
-            Environment.NewLine +
-            $"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."
+            $"""
+            {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}`
+            To fix this, either change the property to use a supported type or configure a custom converter.
+            """
         );
     }
 
@@ -133,11 +133,11 @@ internal class CommandBinder
         }
 
         throw CliFxException.InternalError(
-            $"{memberSchema.GetKind()} {memberSchema.GetFormattedIdentifier()} has an unsupported underlying property type." +
-            Environment.NewLine +
-            $"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."
+            $"""
+            {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}`.
+            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 provided argument(s):" +
-                Environment.NewLine +
-                rawValues.Select(v => '<' + v + '>').JoinToString(" ") +
-                Environment.NewLine +
-                $"Error: {errorMessage}",
+                $"""
+                {memberSchema.GetKind()} {memberSchema.GetFormattedIdentifier()} cannot be set from the provided argument(s):
+                {rawValues.Select(v => '<' + v + '>').JoinToString(" ")}
+                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 +
-            rawValues.Select(v => '<' + v + '>').JoinToString(" ")
+            $"""
+            {memberSchema.GetKind()} {memberSchema.GetFormattedIdentifier()} expects a single argument, but provided with multiple:
+            {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 +
-                "Error(s):" +
-                Environment.NewLine +
-                errors.Select(e => "- " + e.Message).JoinToString(Environment.NewLine)
+                $"""
+                {memberSchema.GetKind()} {memberSchema.GetFormattedIdentifier()} has been provided with an invalid value.
+                Error(s):
+                {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 +
-                remainingParameterInputs
-                    .Select(p => p.GetFormattedIdentifier())
-                    .JoinToString(" ")
+                $"""
+                Unexpected parameter(s):
+                {remainingParameterInputs.Select(p => p.GetFormattedIdentifier()).JoinToString(" ")}
+                """
             );
         }
 
         if (remainingRequiredParameterSchemas.Any())
         {
             throw CliFxException.UserError(
-                "Missing required parameter(s):" +
-                Environment.NewLine +
-                remainingRequiredParameterSchemas
-                    .Select(p => p.GetFormattedIdentifier())
-                    .JoinToString(" ")
+                $"""
+                Missing required parameter(s):
+                {remainingRequiredParameterSchemas.Select(p => p.GetFormattedIdentifier()).JoinToString(" ")}
+                """
             );
         }
     }
@@ -337,22 +336,20 @@ internal class CommandBinder
         if (remainingOptionInputs.Any())
         {
             throw CliFxException.UserError(
-                "Unrecognized option(s):" +
-                Environment.NewLine +
-                remainingOptionInputs
-                    .Select(o => o.GetFormattedIdentifier())
-                    .JoinToString(", ")
+                $"""
+                Unrecognized option(s):
+                {remainingOptionInputs.Select(o => o.GetFormattedIdentifier()).JoinToString(", ")}
+                """
             );
         }
 
         if (remainingRequiredOptionSchemas.Any())
         {
             throw CliFxException.UserError(
-                "Missing required option(s):" +
-                Environment.NewLine +
-                remainingRequiredOptionSchemas
-                    .Select(o => o.GetFormattedIdentifier())
-                    .JoinToString(", ")
+                $"""
+                Missing required option(s):
+                {remainingRequiredOptionSchemas.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/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/ICommand.cs

@@ -9,7 +9,7 @@ namespace CliFx;
 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)
@@ -99,10 +99,8 @@ public partial class ConsoleReader : StreamReader
 
 public partial class ConsoleReader
 {
-    internal static ConsoleReader Create(IConsole console, Stream? stream) => new(
+    internal static ConsoleReader Create(IConsole console, Stream stream) => new(
         console,
-        stream is not null
-            ? Stream.Synchronized(stream)
-            : Stream.Null
+        Stream.Synchronized(stream)
     );
 }

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)
@@ -272,10 +272,8 @@ public partial class ConsoleWriter : StreamWriter
 
 public partial class ConsoleWriter
 {
-    internal static ConsoleWriter Create(IConsole console, Stream? stream) => new(
+    internal static ConsoleWriter Create(IConsole console, Stream stream) => new(
         console,
-        stream is not null
-            ? Stream.Synchronized(stream)
-            : Stream.Null
+        Stream.Synchronized(stream)
     ) {AutoFlush = true};
 }

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 +
-                "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.",
+                $"""
+                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.
+                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 +
-                "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."
+                $"""
+                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>.
+                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>
@@ -42,11 +42,10 @@ public class FakeConsole : IConsole, IDisposable
     public ConsoleColor BackgroundColor { get; set; } = ConsoleColor.Black;
 
     /// <inheritdoc />
-    public void ResetColor()
-    {
-        ForegroundColor = ConsoleColor.Gray;
-        BackgroundColor = ConsoleColor.Black;
-    }
+    public int WindowWidth { get; set; } = 232; // Windows defaults
+
+    /// <inheritdoc />
+    public int WindowHeight { get; set; } = 14; // Windows defaults
 
     /// <inheritdoc />
     public int CursorLeft { get; set; }
@@ -55,13 +54,39 @@ 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)
     {
-        Input = ConsoleReader.Create(this, input);
-        Output = ConsoleWriter.Create(this, output);
-        Error = ConsoleWriter.Create(this, error);
+        Input = ConsoleReader.Create(this, input ?? Stream.Null);
+        Output = ConsoleWriter.Create(this, output ?? Stream.Null);
+        Error = ConsoleWriter.Create(this, error ?? Stream.Null);
+    }
+
+    /// <inheritdoc />
+    public ConsoleKeyInfo ReadKey(bool intercept = false) =>
+        _keys.TryDequeue(out var key)
+            ? key
+            : throw new InvalidOperationException(
+                "Cannot read key because there are no key presses enqueued. " +
+                $"Use the `{nameof(EnqueueKey)}(...)` method to simulate a key press."
+            );
+
+    /// <summary>
+    /// Enqueues a simulated key press, which can then be read by calling <see cref="ReadKey" />.
+    /// </summary>
+    public void EnqueueKey(ConsoleKeyInfo key) => _keys.Enqueue(key);
+
+    /// <inheritdoc />
+    public void ResetColor()
+    {
+        ForegroundColor = ConsoleColor.Gray;
+        BackgroundColor = ConsoleColor.Black;
+    }
+
+    /// <inheritdoc />
+    public void Clear()
+    {
     }
 
     /// <inheritdoc />
@@ -71,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)
@@ -87,25 +112,6 @@ public class FakeConsole : IConsole, IDisposable
         }
     }
 
-    /// <inheritdoc />
-    public void Clear()
-    {
-    }
-
-    /// <inheritdoc />
-    public ConsoleKeyInfo ReadKey(bool intercept = false) =>
-        _keys.TryDequeue(out var key)
-            ? key
-            : throw new InvalidOperationException(
-                "Cannot read key because there are no key presses enqueued. " +
-                $"Use the `{nameof(EnqueueKey)}(...)` method to simulate a key press."
-            );
-
-    /// <summary>
-    /// Enqueues a simulated key press, which can then be read by calling <see cref="ReadKey"/>.
-    /// </summary>
-    public void EnqueueKey(ConsoleKeyInfo key) => _keys.Enqueue(key);
-
     /// <inheritdoc />
     public virtual void Dispose() => _cancellationTokenSource.Dispose();
 }

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

@@ -15,7 +15,7 @@ public interface IConsole
     ConsoleReader Input { get; }
 
     /// <summary>
-    /// Whether the input stream is redirected.
+    /// Gets a value that indicates whether input has been redirected from the standard input stream.
     /// </summary>
     bool IsInputRedirected { get; }
 
@@ -25,7 +25,7 @@ public interface IConsole
     ConsoleWriter Output { get; }
 
     /// <summary>
-    /// Whether the output stream is redirected.
+    /// Gets a value that indicates whether output has been redirected from the standard output stream.
     /// </summary>
     bool IsOutputRedirected { get; }
 
@@ -35,39 +35,59 @@ public interface IConsole
     ConsoleWriter Error { get; }
 
     /// <summary>
-    /// Whether the error stream is redirected.
+    /// Gets a value that indicates whether error output has been redirected from the standard error stream.
     /// </summary>
     bool IsErrorRedirected { get; }
 
     /// <summary>
-    /// Current foreground color.
+    /// Gets or sets the foreground color of the console
     /// </summary>
     ConsoleColor ForegroundColor { get; set; }
 
     /// <summary>
-    /// Current background color.
+    /// Gets or sets the background color of the console.
     /// </summary>
     ConsoleColor BackgroundColor { get; set; }
 
     /// <summary>
-    /// Resets foreground and background colors to their default values.
+    /// Gets or sets the width of the console window.
     /// </summary>
-    void ResetColor();
+    int WindowWidth { get; set; }
 
     /// <summary>
-    /// Cursor left offset.
+    /// Gets or sets the height of the console window.
+    /// </summary>
+    int WindowHeight { get; set; }
+
+    /// <summary>
+    /// Gets or sets the column position of the cursor within the buffer area.
     /// </summary>
     int CursorLeft { get; set; }
 
     /// <summary>
-    /// Cursor top offset.
+    /// Gets or sets the row position of the cursor within the buffer area.
     /// </summary>
     int CursorTop { get; set; }
 
+    /// <summary>
+    /// Obtains the next character or function key pressed by the user.
+    /// </summary>
+    ConsoleKeyInfo ReadKey(bool intercept = false);
+
+    /// <summary>
+    /// Sets the foreground and background console colors to their defaults.
+    /// </summary>
+    void ResetColor();
+
+    /// <summary>
+    /// Clears the console buffer and corresponding console window of display information.
+    /// </summary>
+    void Clear();
+
     /// <summary>
     /// Registers a handler for the interrupt signal (Ctrl+C) on the console and returns
     /// a token representing the cancellation request.
-    /// Subsequent calls to this method have no side-effects and return the same token.
+    /// Subsequent calls to this method have no side effects and return the same token.
     /// </summary>
     /// <remarks>
     /// <para>
@@ -82,25 +102,15 @@ public interface IConsole
     /// </para>
     /// </remarks>
     CancellationToken RegisterCancellationHandler();
-
-    /// <summary>
-    /// Clears the console buffer and corresponding console window of display information.
-    /// </summary>
-    void Clear();
-
-    /// <summary>
-    /// Obtains the next character or function key pressed by the user.
-    /// </summary>
-    ConsoleKeyInfo ReadKey(bool intercept = false);
 }
 
 /// <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)
@@ -112,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)
@@ -124,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
 {
@@ -42,18 +42,19 @@ public class SystemConsole : IConsole, IDisposable
         set => Console.BackgroundColor = value;
     }
 
-    /// <summary>
-    /// Initializes an instance of <see cref="SystemConsole"/>.
-    /// </summary>
-    public SystemConsole()
+    /// <inheritdoc />
+    public int WindowWidth
     {
-        Input = ConsoleReader.Create(this, Console.OpenStandardInput());
-        Output = ConsoleWriter.Create(this, Console.OpenStandardOutput());
-        Error = ConsoleWriter.Create(this, Console.OpenStandardError());
+        get => Console.WindowWidth;
+        set => Console.WindowWidth = value;
     }
 
     /// <inheritdoc />
-    public void ResetColor() => Console.ResetColor();
+    public int WindowHeight
+    {
+        get => Console.WindowHeight;
+        set => Console.WindowHeight = value;
+    }
 
     /// <inheritdoc />
     public int CursorLeft
@@ -69,6 +70,25 @@ public class SystemConsole : IConsole, IDisposable
         set => Console.CursorTop = value;
     }
 
+    /// <summary>
+    /// Initializes an instance of <see cref="SystemConsole" />.
+    /// </summary>
+    public SystemConsole()
+    {
+        Input = ConsoleReader.Create(this, Console.OpenStandardInput());
+        Output = ConsoleWriter.Create(this, Console.OpenStandardOutput());
+        Error = ConsoleWriter.Create(this, Console.OpenStandardError());
+    }
+
+    /// <inheritdoc />
+    public ConsoleKeyInfo ReadKey(bool intercept = false) => Console.ReadKey(intercept);
+
+    /// <inheritdoc />
+    public void ResetColor() => Console.ResetColor();
+
+    /// <inheritdoc />
+    public void Clear() => Console.Clear();
+
     /// <inheritdoc />
     public CancellationToken RegisterCancellationHandler()
     {
@@ -90,12 +110,6 @@ public class SystemConsole : IConsole, IDisposable
         return (_cancellationTokenSource = cts).Token;
     }
 
-    /// <inheritdoc />
-    public void Clear() => Console.Clear();
-
-    /// <inheritdoc />
-    public ConsoleKeyInfo ReadKey(bool intercept = false) => Console.ReadKey(intercept);
-
     /// <inheritdoc />
     public void Dispose()
     {

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;

CliFx/Schema/CommandSchema.cs

@@ -129,15 +129,13 @@ internal partial class CommandSchema
         if (schema is null)
         {
             throw CliFxException.InternalError(
-                $"Type `{type.FullName}` is not a valid command type." +
-                Environment.NewLine +
-                "In order to be a valid command type, it must:" +
-                Environment.NewLine +
-                $"- Implement `{typeof(ICommand).FullName}`" +
-                Environment.NewLine +
-                $"- Be annotated with `{typeof(CommandAttribute).FullName}`" +
-                Environment.NewLine +
-                "- Not be an abstract class"
+                $"""
+                Type `{type.FullName}` is not a valid command type.
+                In order to be a valid command type, it must:
+                - Implement `{typeof(ICommand).FullName}`
+                - Be annotated with `{typeof(CommandAttribute).FullName}`
+                - 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/EnvironmentEx.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Diagnostics;
+using System.Reflection;
+
+namespace CliFx.Utils;
+
+internal static class EnvironmentEx
+{
+    private static readonly Lazy<string?> ProcessPathLazy = new(() =>
+    {
+        using var process = Process.GetCurrentProcess();
+        return process.MainModule?.FileName;
+    });
+
+    public static string? ProcessPath => ProcessPathLazy.Value;
+
+    private static readonly Lazy<Assembly?> EntryAssemblyLazy = new(Assembly.GetEntryAssembly);
+
+    public static Assembly? EntryAssembly => EntryAssemblyLazy.Value;
+}

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/StackFrame.cs

@@ -96,9 +96,10 @@ internal partial class StackFrame
             // If parsing fails, we include the original stacktrace in the
             // exception so that it's shown to the user.
             throw new FormatException(
-                "Could not parse stacktrace:" +
-                Environment.NewLine +
-                stackTrace
+                $"""
+                Could not parse stacktrace:
+                {stackTrace}
+                """
             );
         }
 

Directory.Build.props

@@ -1,12 +1,13 @@
 <Project>
 
   <PropertyGroup>
-    <Version>2.2.4</Version>
+    <Version>2.3.1</Version>
     <Company>Tyrrrz</Company>
     <Copyright>Copyright (C) Oleksii Holub</Copyright>
     <LangVersion>latest</LangVersion>
     <Nullable>enable</Nullable>
     <WarningsAsErrors>nullable</WarningsAsErrors>
+    <CheckEolTargetFramework>false</CheckEolTargetFramework>
     <IsPackable>false</IsPackable>
   </PropertyGroup>
 

Readme.md

@@ -9,12 +9,12 @@
 [![Donate](https://img.shields.io/badge/donate-$$$-8a2be2.svg)](https://tyrrrz.me/donate)
 [![Fuck Russia](https://img.shields.io/badge/fuck-russia-e4181c.svg?labelColor=000000)](https://twitter.com/tyrrrz/status/1495972128977571848)
 
-> 🟢 **Project status**: active<sup>[[?]](https://github.com/Tyrrrz/.github/blob/master/docs/project-status.md)</sup>
+> 🟡 **Project status**: maintenance mode<sup>[[?]](https://github.com/Tyrrrz/.github/blob/master/docs/project-status.md)</sup>
 
 **CliFx** is a simple to use, yet powerful framework for building command line applications.
 Its primary goal is to completely take over the user input layer, allowing you to forget about infrastructural concerns and instead focus on writing your application.
 
-## Terms of use
+## Terms of use<sup>[[?]](https://github.com/Tyrrrz/.github/blob/master/docs/why-so-political.md)</sup>
 
 By using this project or its source code, for any purpose and in any shape or form, you grant your **implicit agreement** to all the following statements:
 
@@ -34,7 +34,7 @@ To learn more about the war and how you can help, [click here](https://tyrrrz.me
 - Complete application framework, not just an argument parser
 - Minimum boilerplate and easy to get started
 - Class-first configuration via attributes
-- Comprehensive autogenerated help text
+- Comprehensive auto-generated help text
 - Support for deeply nested command hierarchies
 - Graceful cancellation via interrupt signals
 - Support for reading and writing binary data
@@ -49,9 +49,7 @@ To learn more about the war and how you can help, [click here](https://tyrrrz.me
 
 ## Usage
 
-### Quick start
-
-![quick start animated](https://i.imgur.com/uouNh2u.gif)
+### Application and commands
 
 To turn your program into a command line interface, modify your `Main` method so that it delegates execution to `CliApplication`.
 You can use `CliApplicationBuilder` to fluently create and configure an instance of `CliApplication`:
@@ -67,10 +65,15 @@ public static class Program
 }
 ```
 
-> ⚠️ Ensure that your `Main()` method returns the integer exit code provided by `CliApplication.RunAsync()`, as shown in the above example.
-Exit code is used to communicate execution result to the parent process, so it's important that your program returns it.
+> **Warning**:
+> Ensure that your `Main()` method returns the integer exit code provided by `CliApplication.RunAsync()`, as shown in the above example.
+> Exit code is used to communicate execution result to the parent process, so it's important that your program propagates it.
 
-The code above calls `AddCommandsFromThisAssembly()` to scan and resolve command types defined within the current assembly.
+> **Note**:
+> When calling `CliApplication.RunAsync()`, **CliFx** resolves command line arguments and environment variables from `Environment.GetCommandLineArgs()` and `Environment.GetEnvironmentVariables()` respectively.
+> You can also provide them explicitly if you choose.
+
+The code above uses `AddCommandsFromThisAssembly()` to detect command types defined within the current assembly.
 Commands are entry points, through which the user can interact with your application.
 
 To define a command, create a new class by implementing the `ICommand` interface and annotate it with the `[Command]` attribute:
@@ -92,12 +95,12 @@ public class HelloWorldCommand : ICommand
 In order to implement `ICommand`, the class needs to define an `ExecuteAsync(...)` method.
 This is the method that gets called by the framework when the user decides to execute this command.
 
-As a parameter, this method takes an instance of `IConsole`, which is an abstraction around the system console.
+As the only parameter, this method takes an instance of `IConsole`, which is an abstraction around the system console.
 Use this abstraction in place of `System.Console` whenever you need to write output, read input, or otherwise interact with the console.
 
 With the basic setup above, the user can now run the application and get a greeting in return:
 
-```sh
+```powershell
 > dotnet myapp.dll
 
 Hello world!
@@ -106,7 +109,7 @@ Hello world!
 Out of the box, the application also comes with built-in `--help` and `--version` options.
 They can be used to show help text or application version respectively:
 
-```sh
+```powershell
 > dotnet myapp.dll --help
 
 MyApp v1.0
@@ -119,7 +122,7 @@ OPTIONS
   --version         Shows version information.
 ```
 
-```sh
+```powershell
 > dotnet myapp.dll --version
 
 v1.0
@@ -128,12 +131,12 @@ v1.0
 ### Parameters and options
 
 Commands can be configured to take input from command line arguments.
-To do that, you need to add properties to the command class and annotate them with special attributes.
+To do that, you need to add properties to the command class and bind them using special attributes.
 
 In **CliFx**, there are two types of argument bindings: **parameters** and **options**.
-Parameters are positional arguments identified by the order they appear in, while options represent sets of arguments identified by their name.
+Parameters are bound from arguments based on the order they appear in, while options are bound by their name.
 
-As an example, here's a command that calculates the logarithm of a value, using a parameter binding to specify the input and an option binding to configure the logarithm base:
+As an example, here's a command that calculates logarithm of a value — it uses a parameter binding to specify the input value and an option binding for the logarithm base:
 
 ```csharp
 [Command]
@@ -141,7 +144,7 @@ public class LogCommand : ICommand
 {
     // Order: 0
     [CommandParameter(0, Description = "Value whose logarithm is to be found.")]
-    public double Value { get; init; }
+    public required double Value { get; init; }
 
     // Name: --base
     // Short name: -b
@@ -158,9 +161,13 @@ public class LogCommand : ICommand
 }
 ```
 
+> **Note**:
+> **CliFx** has built-in analyzers that detect common errors in command definitions.
+> Your code will not compile if the command contains duplicate options, overlapping parameters, or otherwise invalid configuration.
+
 In order to execute this command, at a minimum, the user needs to provide the input value:
 
-```sh
+```powershell
 > dotnet myapp.dll 10000
 
 4
@@ -168,7 +175,7 @@ In order to execute this command, at a minimum, the user needs to provide the in
 
 They can also pass the `base` option to override the default logarithm base of 10:
 
-```sh
+```powershell
 > dotnet myapp.dll 729 -b 3
 
 6
@@ -176,7 +183,7 @@ They can also pass the `base` option to override the default logarithm base of 1
 
 In case the user forgets to specify the `value` parameter, the application will exit with an error:
 
-```sh
+```powershell
 > dotnet myapp.dll -b 10
 
 Missing required parameter(s):
@@ -185,7 +192,7 @@ Missing required parameter(s):
 
 Available parameters and options are also listed in the command's help text, which can be accessed by passing the `--help` option:
 
-```sh
+```powershell
 > dotnet myapp.dll --help
 
 MyApp v1.0
@@ -204,15 +211,15 @@ OPTIONS
 
 Overall, parameters and options are both used to consume input from the command line, but they differ in a few important ways:
 
-|                    | Parameters                                                                                            | Options                                                                                         |
-|--------------------|-------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------|
-| **Identification** | Positional (by relative order).                                                                       | Named (by name or short name).                                                                  |
-| **Requiredness**   | Required by default. Only the last parameter can be configured to be optional.                        | Optional by default. Any option can be configured to be required without limitations.           |
-| **Arity**          | Depends on the property type. Only the last parameter can be bound to a non-scalar type (i.e. array). | Depends on the property type. Any option can be bound to a non-scalar type without limitations. |
-| **Fallback**       | —                                                                                                     | Can be configured to use an environment variable as fallback, in case the option isn't set.     |
+|                    | Parameter                                                                      | Option                                                                                               |
+| ------------------ | ------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------- |
+| **Identification** | Positional (by relative order).                                                | Nominal (by name or short name).                                                                     |
+| **Requiredness**   | Required by default. Only the last parameter can be configured to be optional. | Optional by default. Any option can be configured to be required without limitations.                |
+| **Arity**          | Only the last parameter can be bound to a non-scalar property (i.e. an array). | Any option can be bound to a non-scalar property without limitations.                                |
+| **Fallback**       | —                                                                              | Can be configured to use an environment variable as fallback if the value isn't explicitly provided. |
 
-As a general guideline, it's recommended to use parameters for required inputs that the command can't function without.
-Use options for all other non-required inputs or when specifying the name explicitly makes the usage clearer.
+As a general guideline, use parameters for required inputs that the command can't function without.
+Use options for all other non-required inputs, or when specifying the name explicitly makes the usage clearer.
 
 ### Argument syntax
 
@@ -227,26 +234,26 @@ Here are some examples of how it works:
 - `myapp -xqf bar` sets options `'x'` and `'q'` without value, and option `'f'` to value `"bar"`
 - `myapp -i file1.txt file2.txt` sets option `'i'` to a sequence of values `"file1.txt"` and `"file2.txt"`
 - `myapp -i file1.txt -i file2.txt` sets option `'i'` to a sequence of values `"file1.txt"` and `"file2.txt"`
-- `myapp cmd abc -o` routes to command `cmd` (assuming it's an existing command) with parameter `abc` and sets option `'o'` without value
+- `myapp cmd abc -o` routes to command `cmd` (assuming it's a command) with parameter `abc` and sets option `'o'` without value
 
 Additionally, argument parsing in **CliFx** aims to be as deterministic as possible, ideally yielding the same result regardless of the application configuration.
-In fact, the only context-sensitive part in the parser is the command name resolution, which needs to know the list of available commands in order to discern between arguments that correspond to command name and arguments which map as parameters.
+In fact, the only context-sensitive part in the parser is the command name resolution, which needs to know the list of available commands in order to discern them from parameters.
 
 The parser's context-free nature has several implications on how it consumes arguments.
-For example, passing `myapp -i file1.txt file2.txt` will always be parsed as an option with multiple values, regardless of the arity of the underlying property it's bound to.
+For example, `myapp -i file1.txt file2.txt` will always be parsed as an option with multiple values, regardless of the arity of the underlying property it's bound to.
 Similarly, unseparated arguments in the form of `myapp -ofile` will be treated as five distinct options `'o'`, `'f'`, `'i'`, `'l'`, `'e'`, instead of `'o'` being set to value `"file"`.
 
-Because of these rules, order of arguments is semantically important and must always follow this pattern:
+These rules also make the order of arguments important — command line string is expected to follow this pattern:
 
-```txt
-[directives] [command name] [parameters] [options]
+```powershell
+> myapp [...directives] [command] [...parameters] [...options]
 ```
 
 ### Value conversion
 
-Parameters and options can have the following underlying types:
+Parameters and options can be bound to properties with the following underlying types:
 
-- Standard types
+- Basic types
   - Primitive types (`int`, `bool`, `double`, `ulong`, `char`, etc.)
   - Date and time types (`DateTime`, `DateTimeOffset`, `TimeSpan`)
   - Enum types (converted from either name or numeric value)
@@ -284,7 +291,7 @@ public class FileSizeCalculatorCommand : ICommand
 }
 ```
 
-```sh
+```powershell
 > dotnet myapp.dll file1.bin file2.exe
 
 Total file size: 186368 bytes
@@ -310,7 +317,7 @@ public class FileSizeCalculatorCommand : ICommand
 }
 ```
 
-```sh
+```powershell
 > dotnet myapp.dll --files file1.bin file2.exe
 
 Total file size: 186368 bytes
@@ -366,10 +373,42 @@ public class SurfaceCalculatorCommand : ICommand
 }
 ```
 
+### Environment variables
+
+An option can be configured to use a specific environment variable as fallback.
+If the user does not provide value for such option through command line arguments, the current value of the environment variable will be used instead.
+
+```csharp
+[Command]
+public class AuthCommand : ICommand
+{
+    [CommandOption("token", EnvironmentVariable = "AUTH_TOKEN")]
+    public required string AuthToken { get; init; }
+
+    public ValueTask ExecuteAsync(IConsole console)
+    {
+        console.Output.WriteLine(AuthToken);
+
+        return default;
+    }
+}
+```
+
+```powershell
+> $env:AUTH_TOKEN="test"
+
+> dotnet myapp.dll
+
+test
+```
+
+Environment variables can be configured for options of non-scalar types (arrays, lists, etc.) as well.
+In such case, the values of the environment variable will be split by `Path.PathSeparator` (`;` on Windows, `:` on Unix systems).
+
 ### Multiple commands
 
 In order to facilitate a variety of different workflows, command line applications may provide the user with more than just a single command.
-Complex applications may also nest commands within each other, employing a multi-level hierarchical structure.
+Complex applications may also nest commands underneath each other, employing a multi-level hierarchical structure.
 
 With **CliFx**, this is achieved by simply giving each command a unique name through the `[Command]` attribute.
 Commands that have common name segments are considered to be hierarchically related, which affects how they're listed in the help text.
@@ -404,12 +443,12 @@ public class SubCommand : ICommand
 }
 ```
 
-Once configured, the user can execute a specific command by including its name in the passed arguments.
+Once configured, the user can execute a specific command by pre-pending its name to the passed arguments.
 For example, running `dotnet myapp.dll cmd1 arg1 -p 42` will execute `FirstCommand` in the above example.
 
 Requesting help will show direct subcommands of the current command:
 
-```sh
+```powershell
 > dotnet myapp.dll --help
 
 MyApp v1.0
@@ -431,7 +470,7 @@ You can run `dotnet myapp.dll [command] --help` to show help on a specific comma
 
 The user can also refine their help request by querying it on a specific command:
 
-```sh
+```powershell
 > dotnet myapp.dll cmd1 --help
 
 USAGE
@@ -447,8 +486,9 @@ COMMANDS
 You can run `dotnet myapp.dll cmd1 [command] --help` to show help on a specific command.
 ```
 
-> 💡 Defining a default (unnamed) command is not required.
-If it's absent, running the application without specifying a command will just show the root level help text.
+> **Note**:
+> Defining a default (unnamed) command is not required.
+> If it's absent, running the application without specifying a command will just show the root-level help text.
 
 ### Reporting errors
 
@@ -459,11 +499,11 @@ This special exception can be used to print an error message to the console, ret
 [Command]
 public class DivideCommand : ICommand
 {
-    [CommandOption("dividend", IsRequired = true)]
-    public double Dividend { get; init; }
+    [CommandOption("dividend")]
+    public required double Dividend { get; init; }
 
-    [CommandOption("divisor", IsRequired = true)]
-    public double Divisor { get; init; }
+    [CommandOption("divisor")]
+    public required double Divisor { get; init; }
 
     public ValueTask ExecuteAsync(IConsole console)
     {
@@ -481,7 +521,7 @@ public class DivideCommand : ICommand
 }
 ```
 
-```sh
+```powershell
 > dotnet myapp.dll --dividend 10 --divisor 0
 
 Division by zero is not supported.
@@ -492,8 +532,9 @@ Division by zero is not supported.
 133
 ```
 
-> ⚠️ Even though exit codes are represented by 32-bit integers in .NET, using values outside of 8-bit unsigned range will cause an overflow on Unix systems.
-To avoid unexpected results, use numbers between 1 and 255 for exit codes that indicate failure.
+> **Warning**:
+> Even though exit codes are represented by 32-bit integers in .NET, using values outside 8-bit unsigned range will cause an overflow on Unix systems.
+> To avoid unexpected results, use numbers between 1 and 255 for exit codes that indicate failure.
 
 ### Graceful cancellation
 
@@ -525,15 +566,16 @@ public class CancellableCommand : ICommand
 }
 ```
 
-> ⚠️ Forceful termination of a command can only be delayed once.
-If the user issues a second interrupt signal, the process will be killed immediately without waiting for graceful cancellation.
+> **Warning**:
+> Cancellation handler is only respected when the user sends the interrupt signal for the first time.
+> If the user decides to issue the signal again, the application will terminate immediately regardless of whether the command is cancellation-aware.
 
 ### Type activation
 
-Because **CliFx** takes responsibility for the application's entire lifecycle, it needs to be capable of instantiating various user-defined types at runtime.
+Because **CliFx** takes responsibility for the application's entire lifecycle, it needs to be capable of instantiating various user-defined types at run-time.
 To facilitate that, it uses an interface called `ITypeActivator` that determines how to create a new instance of a given type.
 
-The default implementation of `ITypeActivator` only supports types that have public parameterless constructors, which is sufficient for majority of scenarios.
+The default implementation of `ITypeActivator` only supports types that have public parameterless constructors, which is sufficient for the majority of scenarios.
 However, in some cases you may also want to define a custom initializer, for example when integrating with an external dependency container.
 
 The following example shows how to configure your application to use [`Microsoft.Extensions.DependencyInjection`](https://nuget.org/packages/Microsoft.Extensions.DependencyInjection) as the type activator in **CliFx**:
@@ -555,7 +597,7 @@ public static class Program
 
         return await new CliApplicationBuilder()
             .AddCommandsFromThisAssembly()
-            .UseTypeActivator(serviceProvider.GetService)
+            .UseTypeActivator(serviceProvider)
             .Build()
             .RunAsync();
     }
@@ -652,7 +694,7 @@ To do that, you need to pass the corresponding directive before any other argume
 In order to run the application in debug mode, use the `[debug]` directive.
 This will cause the program to launch in a suspended state, waiting for debugger to be attached to the process:
 
-```sh
+```powershell
 > dotnet myapp.dll [debug] cmd -o
 
 Attach debugger to PID 3148 to continue.
@@ -661,12 +703,12 @@ Attach debugger to PID 3148 to continue.
 To run the application in preview mode, use the `[preview]` directive.
 This will short-circuit the execution and instead print the consumed command line arguments as they were parsed, along with resolved environment variables:
 
-```sh
+```powershell
 > dotnet myapp.dll [preview] cmd arg1 arg2 -o foo --option bar1 bar2
 
 Command line:
   cmd <arg1> <arg2> [-o foo] [--option bar1 bar2]
-  
+
 Environment:
   FOO="123"
   BAR="xyz"
@@ -682,38 +724,7 @@ var app = new CliApplicationBuilder()
     .Build();
 ```
 
-### Environment variables
-
-An option can be configured to use a specific environment variable as fallback.
-If the user does not provide value for such option through command line arguments, the current value of the environment variable will be used instead.
-
-```csharp
-[Command]
-public class AuthCommand : ICommand
-{
-    [CommandOption("token", IsRequired = true, EnvironmentVariable = "AUTH_TOKEN")]
-    public string AuthToken { get; init; }
-
-    public ValueTask ExecuteAsync(IConsole console)
-    {
-        console.Output.WriteLine(AuthToken);
-
-        return default;
-    }
-}
-```
-
-```sh
-> $env:AUTH_TOKEN="test"
-
-> dotnet myapp.dll
-
-test
-```
-
-Environment variables can be configured for options of non-scalar types (arrays, lists, etc.) as well.
-In such case, the values of the environment variable will be split by `Path.PathSeparator` (`;` on Windows, `:` on Linux).
-
 ## Etymology
 
-**CliFx** is made out of "Cli" for "Command Line Interface" and "Fx" for "Framework". It's pronounced as "cliff ex".
+**CliFx** is made out of "Cli" for "Command Line Interface" and "Fx" for "Framework".
+It's pronounced as "cliff ex".