Worked on updating generation to fix a few problems

Author: david-driscoll

.gitignore

@@ -46,3 +46,4 @@ coverage.info
 /codealike.json
 .tmp/
 .nuke/temp/
+**/*.received.cs

src/Protocol/Models/StringOrMarkupContent.cs

@@ -1,4 +1,5 @@
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using Newtonsoft.Json;
 using OmniSharp.Extensions.LanguageServer.Protocol.Serialization.Converters;
 
@@ -17,8 +18,10 @@ public record StringOrMarkupContent
         public MarkupContent? MarkupContent { get; }
         public bool HasMarkupContent => String == null;
 
+        [return: NotNullIfNotNull("value")]
         public static implicit operator StringOrMarkupContent?(string? value) => value is null ? null : new StringOrMarkupContent(value);
 
+        [return: NotNullIfNotNull("markupContent")]
         public static implicit operator StringOrMarkupContent?(MarkupContent? markupContent) => markupContent is null ? null : new StringOrMarkupContent(markupContent);
 
         private string DebuggerDisplay => $"{( HasString ? String : HasMarkupContent ? MarkupContent!.ToString() : string.Empty )}";

test/Generation.Tests/LspFeatureTests.cs

@@ -124,5 +124,168 @@ public partial class Registration
 
             await Verify(GenerationHelpers.GenerateAll(source));
         }
+
+        [Fact]
+        public async Task Supports_Nullable_Params_With_Typed_Data()
+        {
+            var source = @"
+using System.Diagnostics;
+using System.Linq;
+using MediatR;
+using Newtonsoft.Json.Linq;
+using OmniSharp.Extensions.JsonRpc;
+using OmniSharp.Extensions.JsonRpc.Generation;
+using OmniSharp.Extensions.LanguageServer.Protocol.Client;
+using OmniSharp.Extensions.LanguageServer.Protocol.Client.Capabilities;
+using OmniSharp.Extensions.LanguageServer.Protocol.Document;
+using OmniSharp.Extensions.LanguageServer.Protocol.Generation;
+using OmniSharp.Extensions.LanguageServer.Protocol.Serialization;
+using OmniSharp.Extensions.LanguageServer.Protocol.Server;
+using OmniSharp.Extensions.LanguageServer.Protocol.Server.Capabilities;
+using OmniSharp.Extensions.LanguageServer.Protocol;
+using OmniSharp.Extensions.LanguageServer.Protocol.Models;
+
+// ReSharper disable once CheckNamespace
+namespace OmniSharp.Extensions.LanguageServer.Protocol.Test
+{
+    namespace Models
+    {
+        [Parallel]
+        [Method(TextDocumentNames.CodeLens, Direction.ClientToServer)]
+        [GenerateHandler(""OmniSharp.Extensions.LanguageServer.Protocol.Document.Test"")]
+        [GenerateHandlerMethods]
+        [GenerateRequestMethods(typeof(ITextDocumentLanguageClient), typeof(ILanguageClient))]
+        [RegistrationOptions(typeof(SubLensRegistrationOptions))]
+        [Capability(typeof(SubLensCapability))]
+        [Resolver(typeof(SubLens))]
+        public partial record SubLensParams : ITextDocumentIdentifierParams, IWorkDoneProgressParams, IPartialItemsRequest<SubLensContainer?, SubLens>
+        {
+            /// <summary>
+            /// The document to request code lens for.
+            /// </summary>
+            public TextDocumentIdentifier TextDocument { get; init; } = null!;
+        }
+
+        public partial class SubLensContainer {}
+
+        /// <summary>
+        /// A code lens represents a command that should be shown along with
+        /// source text, like the number of references, a way to run tests, etc.
+        ///
+        /// A code lens is _unresolved_ when no command is associated to it. For performance
+        /// reasons the creation of a code lens and resolving should be done in two stages.
+        /// </summary>
+        [DebuggerDisplay(""{"" + nameof(DebuggerDisplay) + "",nq}"")]
+        [Parallel]
+        [Method(TextDocumentNames.CodeLensResolve, Direction.ClientToServer)]
+        [GenerateHandler(""OmniSharp.Extensions.LanguageServer.Protocol.Document.Test"", Name = ""SubLensResolve"")]
+        [GenerateHandlerMethods]
+        [GenerateRequestMethods(typeof(ITextDocumentLanguageClient), typeof(ILanguageClient))]
+        [GenerateTypedData]
+        [GenerateContainer]
+        [Capability(typeof(SubLensCapability))]
+        public partial record SubLens : IRequest<SubLens>, ICanBeResolved, IDoesNotParticipateInRegistration
+        {
+            /// <summary>
+            /// The range in which this code lens is valid. Should only span a single line.
+            /// </summary>
+            public Range Range { get; init; } = null!;
+
+            /// <summary>
+            /// The command this code lens represents.
+            /// </summary>
+            [Optional]
+            public Command? Command { get; init; }
+
+            /// <summary>
+            /// A data entry field that is preserved on a code lens item between
+            /// a code lens and a code lens resolve request.
+            /// </summary>
+            [Optional]
+            public JToken? Data { get; init; }
+
+            private string DebuggerDisplay => $""{Range}{( Command != null ? $"" {Command}"" : """" )}"";
+
+            /// <inheritdoc />
+            public override string ToString()
+            {
+                return DebuggerDisplay;
+            }
+        }
+
+        [GenerateRegistrationOptions(nameof(ServerCapabilities.SubLensProvider))]
+        [RegistrationOptionsConverter(typeof(SubLensRegistrationOptionsConverter))]
+        [RegistrationName(TextDocumentNames.CodeLens)]
+        public partial class SubLensRegistrationOptions : IWorkDoneProgressOptions, ITextDocumentRegistrationOptions
+        {
+            /// <summary>
+            /// Code lens has a resolve provider as well.
+            /// </summary>
+            [Optional]
+            public bool ResolveProvider { get; set; }
+
+            private class SubLensRegistrationOptionsConverter : RegistrationOptionsConverterBase<SubLensRegistrationOptions, StaticOptions>
+            {
+                private readonly IHandlersManager _handlersManager;
+
+                public SubLensRegistrationOptionsConverter(IHandlersManager handlersManager)
+                {
+                    _handlersManager = handlersManager;
+                }
+
+                public override StaticOptions Convert(SubLensRegistrationOptions source)
+                {
+                    return new()
+                    {
+                        ResolveProvider = source.ResolveProvider || _handlersManager.Descriptors.Any(z => z.HandlerType == typeof(ISubLensResolveHandler)),
+                        WorkDoneProgress = source.WorkDoneProgress
+                    };
+                }
+            }
+        }
+        
+        [Parallel]
+        [Method(WorkspaceNames.CodeLensRefresh, Direction.ServerToClient)]
+        [GenerateHandler(""OmniSharp.Extensions.LanguageServer.Protocol.Workspace.Test"")]
+        [GenerateHandlerMethods]
+        [GenerateRequestMethods(typeof(IWorkspaceLanguageServer), typeof(ILanguageServer))]
+        [Capability(typeof(SubLensWorkspaceClientCapabilities))]
+        public partial record SubLensRefreshParams : IRequest;
+    }
+
+    namespace Client.Capabilities
+    {
+        [CapabilityKey(nameof(ClientCapabilities.TextDocument), nameof(TextDocumentClientCapabilities.CodeLens))]
+        public partial class SubLensCapability : DynamicCapability
+        {
+        }
+
+        /// <summary>
+        /// Capabilities specific to the code lens requests scoped to the
+        /// workspace.
+        ///
+        /// @since 3.16.0.
+        /// </summary>
+        [CapabilityKey(nameof(ClientCapabilities.Workspace), nameof(WorkspaceClientCapabilities.CodeLens))]
+        public class SubLensWorkspaceClientCapabilities : ICapability
+        {
+            /// <summary>
+            /// Whether the client implementation supports a refresh request send from the server
+            /// to the client. This is useful if a server detects a change which requires a
+            /// re-calculation of all code lenses.
+            /// </summary>
+            [Optional]
+            public bool RefreshSupport { get; set; }
+        }
+    }
+
+    namespace Document
+    {
+    }
+}
+";
+
+            await Verify(GenerationHelpers.GenerateAll(source));
+        }
     }
 }

test/Lsp.Integration.Tests/TypedCodeActionTests.cs renamed to test/Lsp.Integration.Tests/TypedCodeActionTests.cs.disable

@@ -39,7 +39,7 @@ public async Task Should_Aggregate_With_All_Related_Handlers()
                     options.OnCodeLens(
                         codeLensParams =>
                         {
-                            return Task.FromResult(
+                            return Task.FromResult<CodeLensContainer?>(
                                 new CodeLensContainer<Data>(
                                     new CodeLens<Data>
                                     {
@@ -71,7 +71,7 @@ public async Task Should_Aggregate_With_All_Related_Handlers()
                     options.OnCodeLens(
                         codeLensParams =>
                         {
-                            return Task.FromResult(
+                            return Task.FromResult<CodeLensContainer?>(
                                 new CodeLensContainer<Nested>(
                                     new CodeLens<Nested>
                                     {
@@ -98,7 +98,7 @@ public async Task Should_Aggregate_With_All_Related_Handlers()
                     options.OnCodeLens(
                         codeLensParams =>
                         {
-                            return Task.FromResult(
+                            return Task.FromResult<CodeLensContainer?>(
                                 new CodeLensContainer(
                                     new CodeLens
                                     {
@@ -121,7 +121,7 @@ public async Task Should_Aggregate_With_All_Related_Handlers()
                     options.OnCodeLens(
                         codeLensParams =>
                         {
-                            return Task.FromResult(
+                            return Task.FromResult<CodeLensContainer?>(
                                 new CodeLensContainer(
                                     new CodeLens
                                     {
@@ -167,7 +167,7 @@ public async Task Should_Resolve_With_Data_Capability()
                     options.OnCodeLens(
                         (codeLensParams, capability, token) =>
                         {
-                            return Task.FromResult(
+                            return Task.FromResult<CodeLensContainer?>(
                                 new CodeLensContainer<Data>(
                                     new CodeLens<Data>
                                     {
@@ -270,7 +270,7 @@ public async Task Should_Resolve_With_Data_CancellationToken()
                     options.OnCodeLens(
                         (codeLensParams, token) =>
                         {
-                            return Task.FromResult(
+                            return Task.FromResult<CodeLensContainer<Data>>(
                                 new CodeLensContainer<Data>(
                                     new CodeLens<Data>
                                     {