/// <summary>
        /// Handle a CodeLens resolve request from VSCode.
        /// </summary>
        /// <param name="codeLens">The CodeLens to be resolved/updated.</param>
        /// <param name="requestContext"></param>
        private async Task HandleCodeLensResolveRequest(
            LanguageServer.CodeLens codeLens,
            RequestContext <LanguageServer.CodeLens> requestContext)
        {
            if (codeLens.Data != null)
            {
                // TODO: Catch deserializtion exception on bad object
                CodeLensData codeLensData = codeLens.Data.ToObject <CodeLensData>();

                ICodeLensProvider originalProvider =
                    Providers.FirstOrDefault(
                        provider => provider.ProviderId.Equals(codeLensData.ProviderId));

                if (originalProvider != null)
                {
                    ScriptFile scriptFile =
                        _editorSession.Workspace.GetFile(
                            codeLensData.Uri);

                    ScriptRegion region = new ScriptRegion
                    {
                        StartLineNumber   = codeLens.Range.Start.Line + 1,
                        StartColumnNumber = codeLens.Range.Start.Character + 1,
                        EndLineNumber     = codeLens.Range.End.Line + 1,
                        EndColumnNumber   = codeLens.Range.End.Character + 1
                    };

                    CodeLens originalCodeLens =
                        new CodeLens(
                            originalProvider,
                            scriptFile,
                            region);

                    var resolvedCodeLens =
                        await originalProvider.ResolveCodeLensAsync(
                            originalCodeLens,
                            CancellationToken.None);

                    await requestContext.SendResult(
                        resolvedCodeLens.ToProtocolCodeLens(
                            _jsonSerializer));
                }
                else
                {
                    await requestContext.SendError(
                        $"Could not find provider for the original CodeLens: {codeLensData.ProviderId}");
                }
            }
        }
        /// <summary>
        /// Handles a request for CodeLenses from VSCode.
        /// </summary>
        /// <param name="codeLensParams">Parameters on the CodeLens request that was received.</param>
        /// <param name="requestContext"></param>
        private async Task HandleCodeLensRequest(
            CodeLensRequest codeLensParams,
            RequestContext <LanguageServer.CodeLens[]> requestContext)
        {
            ScriptFile scriptFile = _editorSession.Workspace.GetFile(
                codeLensParams.TextDocument.Uri);

            CodeLens[] codeLensResults = ProvideCodeLenses(scriptFile);

            var codeLensResponse = new LanguageServer.CodeLens[codeLensResults.Length];

            for (int i = 0; i < codeLensResults.Length; i++)
            {
                codeLensResponse[i] = codeLensResults[i].ToProtocolCodeLens(
                    new CodeLensData
                {
                    Uri        = codeLensResults[i].File.ClientFilePath,
                    ProviderId = codeLensResults[i].Provider.ProviderId
                },
                    _jsonSerializer);
            }

            await requestContext.SendResult(codeLensResponse);
        }