public async ValueTask <ManagedHotReloadUpdates> GetUpdatesAsync(CancellationToken cancellationToken)
        {
            if (_disabled)
            {
                return(new ManagedHotReloadUpdates(ImmutableArray <ManagedHotReloadUpdate> .Empty, ImmutableArray <ManagedHotReloadDiagnostic> .Empty));
            }

            try
            {
                var solution = GetCurrentCompileTimeSolution();
                var(moduleUpdates, diagnosticData, rudeEdits) = await GetDebuggingSession().EmitSolutionUpdateAsync(solution, s_solutionActiveStatementSpanProvider, _diagnosticService, _diagnosticUpdateSource, cancellationToken).ConfigureAwait(false);

                var updates = moduleUpdates.Updates.SelectAsArray(
                    update => new ManagedHotReloadUpdate(update.Module, update.ILDelta, update.MetadataDelta));

                var diagnostics = await EmitSolutionUpdateResults.GetHotReloadDiagnosticsAsync(solution, diagnosticData, rudeEdits, cancellationToken).ConfigureAwait(false);

                return(new ManagedHotReloadUpdates(updates, diagnostics));
            }
            catch (Exception e) when(FatalError.ReportAndCatchUnlessCanceled(e, cancellationToken))
            {
                var descriptor = EditAndContinueDiagnosticDescriptors.GetDescriptor(RudeEditKind.InternalError);

                // TODO: better error
                var diagnostic = new ManagedHotReloadDiagnostic(
                    descriptor.Id,
                    string.Format(descriptor.MessageFormat.ToString(), "", e.Message),
                    ManagedHotReloadDiagnosticSeverity.Error,
                    filePath: "",
                    span: default);

                return(new ManagedHotReloadUpdates(ImmutableArray <ManagedHotReloadUpdate> .Empty, ImmutableArray.Create(diagnostic)));
            }
        }
        public async ValueTask <ManagedHotReloadUpdates> GetHotReloadUpdatesAsync(Solution solution, CancellationToken cancellationToken)
        {
            var result = await _encService.EmitSolutionUpdateAsync(GetSessionId(), solution, s_noActiveStatementSpanProvider, cancellationToken).ConfigureAwait(false);

            var updates = result.ModuleUpdates.Updates.SelectAsArray(
                update => new ManagedHotReloadUpdate(update.Module, update.ILDelta, update.MetadataDelta, update.PdbDelta, update.UpdatedTypes));

            var diagnostics = await EmitSolutionUpdateResults.GetHotReloadDiagnosticsAsync(solution, result.GetDiagnosticData(solution), result.RudeEdits, result.GetSyntaxErrorData(solution), cancellationToken).ConfigureAwait(false);

            return(new ManagedHotReloadUpdates(updates, diagnostics.FromContract()));
        }
        public async ValueTask <ManagedHotReloadUpdates> GetHotReloadUpdatesAsync(CancellationToken cancellationToken)
        {
            if (_disabled)
            {
                return(new ManagedHotReloadUpdates(ImmutableArray <ManagedHotReloadUpdate> .Empty, ImmutableArray <ManagedHotReloadDiagnostic> .Empty));
            }

            var solution = GetCurrentCompileTimeSolution();

            var(moduleUpdates, diagnosticData, rudeEdits, syntaxError) = await GetDebuggingSession().EmitSolutionUpdateAsync(solution, s_noActiveStatementSpanProvider, _diagnosticService, _diagnosticUpdateSource, cancellationToken).ConfigureAwait(false);

            _pendingUpdatedSolution = solution;

            var updates = moduleUpdates.Updates.SelectAsArray(
                update => new ManagedHotReloadUpdate(update.Module, update.ILDelta, update.MetadataDelta, update.UpdatedTypes));

            var diagnostics = await EmitSolutionUpdateResults.GetHotReloadDiagnosticsAsync(solution, diagnosticData, rudeEdits, syntaxError, cancellationToken).ConfigureAwait(false);

            return(new ManagedHotReloadUpdates(updates, diagnostics.FromContract()));
        }
        public async Task GetHotReloadDiagnostics()
        {
            using var workspace = new TestWorkspace(composition: FeaturesTestCompositions.Features);

            var sourcePath = Path.Combine(TempRoot.Root, "x", "a.cs");
            var razorPath  = Path.Combine(TempRoot.Root, "a.razor");

            var document = workspace.CurrentSolution.
                           AddProject("proj", "proj", LanguageNames.CSharp).
                           WithMetadataReferences(TargetFrameworkUtil.GetReferences(TargetFramework.Standard)).
                           AddDocument(sourcePath, SourceText.From("class C {}", Encoding.UTF8), filePath: Path.Combine(TempRoot.Root, sourcePath));

            var solution = document.Project.Solution;

            var diagnosticData = ImmutableArray.Create(
                new DiagnosticData(
                    id: "CS0001",
                    category: "Test",
                    message: "warning",
                    enuMessageForBingSearch: "test2 message format",
                    severity: DiagnosticSeverity.Warning,
                    defaultSeverity: DiagnosticSeverity.Warning,
                    isEnabledByDefault: true,
                    warningLevel: 0,
                    customTags: ImmutableArray.Create("Test2"),
                    properties: ImmutableDictionary <string, string?> .Empty,
                    document.Project.Id,
                    new DiagnosticDataLocation(document.Id, new TextSpan(1, 2), "a.cs", 0, 0, 0, 5, "a.razor", 10, 10, 10, 15),
                    language: "C#",
                    title: "title",
                    description: "description",
                    helpLink: "http://link"),
                new DiagnosticData(
                    id: "CS0012",
                    category: "Test",
                    message: "error",
                    enuMessageForBingSearch: "test2 message format",
                    severity: DiagnosticSeverity.Error,
                    defaultSeverity: DiagnosticSeverity.Warning,
                    isEnabledByDefault: true,
                    warningLevel: 0,
                    customTags: ImmutableArray.Create("Test2"),
                    properties: ImmutableDictionary <string, string?> .Empty,
                    document.Project.Id,
                    new DiagnosticDataLocation(document.Id, new TextSpan(1, 2), originalFilePath: sourcePath, 0, 0, 0, 5, mappedFilePath: @"..\a.razor", 10, 10, 10, 15),
                    language: "C#",
                    title: "title",
                    description: "description",
                    helpLink: "http://link"));

            var rudeEdits = ImmutableArray.Create(
                (document.Id, ImmutableArray.Create(new RudeEditDiagnostic(RudeEditKind.Insert, TextSpan.FromBounds(1, 10), 123, new[] { "a" }))),
                (document.Id, ImmutableArray.Create(new RudeEditDiagnostic(RudeEditKind.Delete, TextSpan.FromBounds(1, 10), 123, new[] { "b" }))));

            var actual = await EmitSolutionUpdateResults.GetHotReloadDiagnosticsAsync(solution, diagnosticData, rudeEdits, CancellationToken.None);

            AssertEx.Equal(new[]
            {
                $@"Error CS0012: {razorPath} (10,10)-(10,15): error",
                $@"Error ENC0021: {sourcePath} (0,1)-(0,10): {string.Format(FeaturesResources.Adding_0_will_prevent_the_debug_session_from_continuing, "a")}",
                $@"Error ENC0033: {sourcePath} (0,1)-(0,10): {string.Format(FeaturesResources.Deleting_0_will_prevent_the_debug_session_from_continuing, "b")}"
            }, actual.Select(d => $"{d.Severity} {d.Id}: {d.FilePath} {d.Span.GetDebuggerDisplay()}: {d.Message}"));
        }