public DocumentPullDiagnosticHandler(
IDiagnosticAnalyzerService analyzerService,
EditAndContinueDiagnosticUpdateSource editAndContinueDiagnosticUpdateSource,
IGlobalOptionService globalOptions)
: base(analyzerService, editAndContinueDiagnosticUpdateSource, globalOptions)
{
}
public VSTypeScriptDocumentPullDiagnosticHandlerFactory(
IDiagnosticService diagnosticService,
IDiagnosticAnalyzerService analyzerService,
EditAndContinueDiagnosticUpdateSource editAndContinueDiagnosticUpdateSource,
IGlobalOptionService globalOptions) : base(diagnosticService, analyzerService, editAndContinueDiagnosticUpdateSource, globalOptions)
{
}
public DocumentPullDiagnosticHandler(
IDiagnosticService diagnosticService,
IDiagnosticAnalyzerService analyzerService,
EditAndContinueDiagnosticUpdateSource editAndContinueDiagnosticUpdateSource)
: base(diagnosticService, editAndContinueDiagnosticUpdateSource)
{
_analyzerService = analyzerService;
}
public WorkspacePullDiagnosticHandlerFactory(
IDiagnosticService diagnosticService,
EditAndContinueDiagnosticUpdateSource editAndContinueDiagnosticUpdateSource,
IGlobalOptionService globalOptions)
{
_diagnosticService = diagnosticService;
_editAndContinueDiagnosticUpdateSource = editAndContinueDiagnosticUpdateSource;
_globalOptions = globalOptions;
}
public ExperimentalWorkspacePullDiagnosticHandlerProvider(
IDiagnosticService diagnosticService,
IDiagnosticAnalyzerService analyzerService,
EditAndContinueDiagnosticUpdateSource editAndContinueDiagnosticUpdateSource)
{
_diagnosticService = diagnosticService;
_analyzerService = analyzerService;
_editAndContinueDiagnosticUpdateSource = editAndContinueDiagnosticUpdateSource;
}
public DocumentPullDiagnosticHandlerFactory(
IDiagnosticAnalyzerService analyzerService,
EditAndContinueDiagnosticUpdateSource editAndContinueDiagnosticUpdateSource,
IGlobalOptionService globalOptions)
{
_analyzerService = analyzerService;
_editAndContinueDiagnosticUpdateSource = editAndContinueDiagnosticUpdateSource;
_globalOptions = globalOptions;
}
public DocumentPullDiagnosticHandler(
WellKnownLspServerKinds serverKind,
IDiagnosticService diagnosticService,
IDiagnosticAnalyzerService analyzerService,
EditAndContinueDiagnosticUpdateSource editAndContinueDiagnosticUpdateSource)
: base(serverKind, diagnosticService, editAndContinueDiagnosticUpdateSource)
{
_analyzerService = analyzerService;
}
public ManagedHotReloadLanguageService(
VisualStudioWorkspace workspace,
IManagedHotReloadService hotReloadService,
IDiagnosticAnalyzerService diagnosticService,
EditAndContinueDiagnosticUpdateSource diagnosticUpdateSource)
{
_proxy = new RemoteEditAndContinueServiceProxy(workspace);
_debuggerService = new DebuggerService(hotReloadService);
_diagnosticService = diagnosticService;
_diagnosticUpdateSource = diagnosticUpdateSource;
}
public ExperimentalWorkspacePullDiagnosticHandlerFactory(
IDiagnosticService diagnosticService,
IDiagnosticAnalyzerService analyzerService,
EditAndContinueDiagnosticUpdateSource editAndContinueDiagnosticUpdateSource,
IGlobalOptionService globalOptions)
{
_diagnosticService = diagnosticService;
_analyzerService = analyzerService;
_editAndContinueDiagnosticUpdateSource = editAndContinueDiagnosticUpdateSource;
_globalOptions = globalOptions;
}
public ManagedEditAndContinueLanguageService(
VisualStudioWorkspace workspace,
IManagedEditAndContinueDebuggerService debuggerService,
IDiagnosticAnalyzerService diagnosticService,
EditAndContinueDiagnosticUpdateSource diagnosticUpdateSource)
{
_proxy = new RemoteEditAndContinueServiceProxy(workspace);
_debuggingService = workspace.Services.GetRequiredService <IDebuggingWorkspaceService>();
_activeStatementTrackingService = workspace.Services.GetRequiredService <IActiveStatementTrackingService>();
_debuggerService = debuggerService;
_diagnosticService = diagnosticService;
_diagnosticUpdateSource = diagnosticUpdateSource;
}
public async Task Proxy(TestHost testHost)
{
var localComposition = EditorTestCompositions.EditorFeatures.WithTestHostParts(testHost);
if (testHost == TestHost.InProcess)
{
localComposition = localComposition.AddParts(typeof(MockEncServiceFactory));
}
using var localWorkspace = new TestWorkspace(composition: localComposition);
MockEditAndContinueWorkspaceService mockEncService;
var clientProvider = (InProcRemoteHostClientProvider?)localWorkspace.Services.GetService <IRemoteHostClientProvider>();
if (testHost == TestHost.InProcess)
{
Assert.Null(clientProvider);
mockEncService = (MockEditAndContinueWorkspaceService)localWorkspace.Services.GetRequiredService <IEditAndContinueWorkspaceService>();
}
else
{
Assert.NotNull(clientProvider);
clientProvider !.AdditionalRemoteParts = new[] { typeof(MockEncServiceFactory) };
var client = await InProcRemoteHostClient.GetTestClientAsync(localWorkspace).ConfigureAwait(false);
var remoteWorkspace = client.TestData.WorkspaceManager.GetWorkspace();
mockEncService = (MockEditAndContinueWorkspaceService)remoteWorkspace.Services.GetRequiredService <IEditAndContinueWorkspaceService>();
}
localWorkspace.ChangeSolution(localWorkspace.CurrentSolution.
AddProject("proj", "proj", LanguageNames.CSharp).
AddMetadataReferences(TargetFrameworkUtil.GetReferences(TargetFramework.Mscorlib40)).
AddDocument("test.cs", SourceText.From("class C { }", Encoding.UTF8), filePath: "test.cs").Project.Solution);
var solution = localWorkspace.CurrentSolution;
var project = solution.Projects.Single();
var document = project.Documents.Single();
var mockDiagnosticService = new MockDiagnosticAnalyzerService();
void VerifyReanalyzeInvocation(ImmutableArray <DocumentId> documentIds)
{
AssertEx.Equal(documentIds, mockDiagnosticService.DocumentsToReanalyze);
mockDiagnosticService.DocumentsToReanalyze.Clear();
}
var diagnosticUpdateSource = new EditAndContinueDiagnosticUpdateSource();
var emitDiagnosticsUpdated = new List <DiagnosticsUpdatedArgs>();
var emitDiagnosticsClearedCount = 0;
diagnosticUpdateSource.DiagnosticsUpdated += (object sender, DiagnosticsUpdatedArgs args) => emitDiagnosticsUpdated.Add(args);
diagnosticUpdateSource.DiagnosticsCleared += (object sender, EventArgs args) => emitDiagnosticsClearedCount++;
var span1 = new LinePositionSpan(new LinePosition(1, 2), new LinePosition(1, 5));
var moduleId1 = new Guid("{44444444-1111-1111-1111-111111111111}");
var methodId1 = new ManagedMethodId(moduleId1, token: 0x06000003, version: 2);
var instructionId1 = new ManagedInstructionId(methodId1, ilOffset: 10);
var as1 = new ManagedActiveStatementDebugInfo(
instructionId1,
documentName: "test.cs",
span1.ToSourceSpan(),
flags: ActiveStatementFlags.IsLeafFrame | ActiveStatementFlags.PartiallyExecuted);
var methodId2 = new ManagedModuleMethodId(token: 0x06000002, version: 1);
var exceptionRegionUpdate1 = new ManagedExceptionRegionUpdate(
methodId2,
delta: 1,
newSpan: new SourceSpan(1, 2, 1, 5));
var document1 = localWorkspace.CurrentSolution.Projects.Single().Documents.Single();
var activeSpans1 = ImmutableArray.Create(
new ActiveStatementSpan(0, new LinePositionSpan(new LinePosition(1, 2), new LinePosition(3, 4)), ActiveStatementFlags.IsNonLeafFrame, document.Id));
var activeStatementSpanProvider = new ActiveStatementSpanProvider((documentId, path, cancellationToken) =>
{
Assert.Equal(document1.Id, documentId);
Assert.Equal("test.cs", path);
return(new(activeSpans1));
});
var proxy = new RemoteEditAndContinueServiceProxy(localWorkspace);
// StartDebuggingSession
IManagedEditAndContinueDebuggerService?remoteDebuggeeModuleMetadataProvider = null;
var debuggingSession = mockEncService.StartDebuggingSessionImpl = (solution, debuggerService, captureMatchingDocuments, captureAllMatchingDocuments, reportDiagnostics) =>
{
Assert.Equal("proj", solution.Projects.Single().Name);
AssertEx.Equal(new[] { document1.Id }, captureMatchingDocuments);
Assert.False(captureAllMatchingDocuments);
Assert.True(reportDiagnostics);
remoteDebuggeeModuleMetadataProvider = debuggerService;
return(new DebuggingSessionId(1));
};
var sessionProxy = await proxy.StartDebuggingSessionAsync(
localWorkspace.CurrentSolution,
debuggerService : new MockManagedEditAndContinueDebuggerService()
{
IsEditAndContinueAvailable = _ => new ManagedEditAndContinueAvailability(ManagedEditAndContinueAvailabilityStatus.NotAllowedForModule, "can't do enc"),
GetActiveStatementsImpl = () => ImmutableArray.Create(as1)
},
captureMatchingDocuments : ImmutableArray.Create(document1.Id),
captureAllMatchingDocuments : false,
reportDiagnostics : true,
CancellationToken.None).ConfigureAwait(false);
Contract.ThrowIfNull(sessionProxy);
// BreakStateEntered
mockEncService.BreakStateEnteredImpl = (out ImmutableArray <DocumentId> documentsToReanalyze) =>
{
documentsToReanalyze = ImmutableArray.Create(document.Id);
};
await sessionProxy.BreakStateEnteredAsync(mockDiagnosticService, CancellationToken.None).ConfigureAwait(false);
VerifyReanalyzeInvocation(ImmutableArray.Create(document.Id));
var activeStatement = (await remoteDebuggeeModuleMetadataProvider !.GetActiveStatementsAsync(CancellationToken.None).ConfigureAwait(false)).Single();
Assert.Equal(as1.ActiveInstruction, activeStatement.ActiveInstruction);
Assert.Equal(as1.SourceSpan, activeStatement.SourceSpan);
Assert.Equal(as1.Flags, activeStatement.Flags);
var availability = await remoteDebuggeeModuleMetadataProvider !.GetAvailabilityAsync(moduleId1, CancellationToken.None).ConfigureAwait(false);
Assert.Equal(new ManagedEditAndContinueAvailability(ManagedEditAndContinueAvailabilityStatus.NotAllowedForModule, "can't do enc"), availability);
// HasChanges
mockEncService.HasChangesImpl = (solution, activeStatementSpanProvider, sourceFilePath) =>
{
Assert.Equal("proj", solution.Projects.Single().Name);
Assert.Equal("test.cs", sourceFilePath);
AssertEx.Equal(activeSpans1, activeStatementSpanProvider(document1.Id, "test.cs", CancellationToken.None).AsTask().Result);
return(true);
};
Assert.True(await sessionProxy.HasChangesAsync(localWorkspace.CurrentSolution, activeStatementSpanProvider, "test.cs", CancellationToken.None).ConfigureAwait(false));
// EmitSolutionUpdate
var diagnosticDescriptor1 = EditAndContinueDiagnosticDescriptors.GetDescriptor(EditAndContinueErrorCode.ErrorReadingFile);
mockEncService.EmitSolutionUpdateImpl = (solution, activeStatementSpanProvider) =>
{
var project = solution.Projects.Single();
Assert.Equal("proj", project.Name);
AssertEx.Equal(activeSpans1, activeStatementSpanProvider(document1.Id, "test.cs", CancellationToken.None).AsTask().Result);
var deltas = ImmutableArray.Create(new ManagedModuleUpdate(
module: moduleId1,
ilDelta: ImmutableArray.Create <byte>(1, 2),
metadataDelta: ImmutableArray.Create <byte>(3, 4),
pdbDelta: ImmutableArray.Create <byte>(5, 6),
updatedMethods: ImmutableArray.Create(0x06000001),
updatedTypes: ImmutableArray.Create(0x02000001),
sequencePoints: ImmutableArray.Create(new SequencePointUpdates("file.cs", ImmutableArray.Create(new SourceLineUpdate(1, 2)))),
activeStatements: ImmutableArray.Create(new ManagedActiveStatementUpdate(instructionId1.Method.Method, instructionId1.ILOffset, span1.ToSourceSpan())),
exceptionRegions: ImmutableArray.Create(exceptionRegionUpdate1)));
var syntaxTree = project.Documents.Single().GetSyntaxTreeSynchronously(CancellationToken.None) !;
var documentDiagnostic = Diagnostic.Create(diagnosticDescriptor1, Location.Create(syntaxTree, TextSpan.FromBounds(1, 2)), new[] { "doc", "some error" });
var projectDiagnostic = Diagnostic.Create(diagnosticDescriptor1, Location.None, new[] { "proj", "some error" });
var updates = new ManagedModuleUpdates(ManagedModuleUpdateStatus.Ready, deltas);
var diagnostics = ImmutableArray.Create((project.Id, ImmutableArray.Create(documentDiagnostic, projectDiagnostic)));
var documentsWithRudeEdits = ImmutableArray.Create((document1.Id, ImmutableArray <RudeEditDiagnostic> .Empty));
return(new(updates, diagnostics, documentsWithRudeEdits));
};
var(updates, _, _) = await sessionProxy.EmitSolutionUpdateAsync(localWorkspace.CurrentSolution, activeStatementSpanProvider, mockDiagnosticService, diagnosticUpdateSource, CancellationToken.None).ConfigureAwait(false);
VerifyReanalyzeInvocation(ImmutableArray.Create(document1.Id));
Assert.Equal(ManagedModuleUpdateStatus.Ready, updates.Status);
Assert.Equal(1, emitDiagnosticsClearedCount);
emitDiagnosticsClearedCount = 0;
AssertEx.Equal(new[]
{
$"[{project.Id}] Error ENC1001: test.cs(0, 1, 0, 2): {string.Format(FeaturesResources.ErrorReadingFile, "doc", "some error")}",
$"[{project.Id}] Error ENC1001: {string.Format(FeaturesResources.ErrorReadingFile, "proj", "some error")}"
},
emitDiagnosticsUpdated.Select(update =>
{
var d = update.GetPushDiagnostics(localWorkspace, InternalDiagnosticsOptions.NormalDiagnosticMode).Single();
return($"[{d.ProjectId}] {d.Severity} {d.Id}:" +
(d.DataLocation != null ? $" {d.DataLocation.OriginalFilePath}({d.DataLocation.OriginalStartLine}, {d.DataLocation.OriginalStartColumn}, {d.DataLocation.OriginalEndLine}, {d.DataLocation.OriginalEndColumn}):" : "") +
$" {d.Message}");
}));
emitDiagnosticsUpdated.Clear();
var delta = updates.Updates.Single();
Assert.Equal(moduleId1, delta.Module);
AssertEx.Equal(new byte[] { 1, 2 }, delta.ILDelta);
AssertEx.Equal(new byte[] { 3, 4 }, delta.MetadataDelta);
AssertEx.Equal(new byte[] { 5, 6 }, delta.PdbDelta);
AssertEx.Equal(new[] { 0x06000001 }, delta.UpdatedMethods);
AssertEx.Equal(new[] { 0x02000001 }, delta.UpdatedTypes);
var lineEdit = delta.SequencePoints.Single();
Assert.Equal("file.cs", lineEdit.FileName);
AssertEx.Equal(new[] { new SourceLineUpdate(1, 2) }, lineEdit.LineUpdates);
Assert.Equal(exceptionRegionUpdate1, delta.ExceptionRegions.Single());
var activeStatements = delta.ActiveStatements.Single();
Assert.Equal(instructionId1.Method.Method, activeStatements.Method);
Assert.Equal(instructionId1.ILOffset, activeStatements.ILOffset);
Assert.Equal(span1, activeStatements.NewSpan.ToLinePositionSpan());
// CommitSolutionUpdate
mockEncService.CommitSolutionUpdateImpl = (out ImmutableArray <DocumentId> documentsToReanalyze) =>
{
documentsToReanalyze = ImmutableArray.Create(document.Id);
};
await sessionProxy.CommitSolutionUpdateAsync(mockDiagnosticService, CancellationToken.None).ConfigureAwait(false);
VerifyReanalyzeInvocation(ImmutableArray.Create(document.Id));
// DiscardSolutionUpdate
var called = false;
mockEncService.DiscardSolutionUpdateImpl = () => called = true;
await sessionProxy.DiscardSolutionUpdateAsync(CancellationToken.None).ConfigureAwait(false);
Assert.True(called);
// GetCurrentActiveStatementPosition
mockEncService.GetCurrentActiveStatementPositionImpl = (solution, activeStatementSpanProvider, instructionId) =>
{
Assert.Equal("proj", solution.Projects.Single().Name);
Assert.Equal(instructionId1, instructionId);
AssertEx.Equal(activeSpans1, activeStatementSpanProvider(document1.Id, "test.cs", CancellationToken.None).AsTask().Result);
return(new LinePositionSpan(new LinePosition(1, 2), new LinePosition(1, 5)));
};
Assert.Equal(span1, await sessionProxy.GetCurrentActiveStatementPositionAsync(
localWorkspace.CurrentSolution,
activeStatementSpanProvider,
instructionId1,
CancellationToken.None).ConfigureAwait(false));
// IsActiveStatementInExceptionRegion
mockEncService.IsActiveStatementInExceptionRegionImpl = (solution, instructionId) =>
{
Assert.Equal(instructionId1, instructionId);
return(true);
};
Assert.True(await sessionProxy.IsActiveStatementInExceptionRegionAsync(localWorkspace.CurrentSolution, instructionId1, CancellationToken.None).ConfigureAwait(false));
// GetBaseActiveStatementSpans
var activeStatementSpan1 = new ActiveStatementSpan(0, span1, ActiveStatementFlags.IsNonLeafFrame | ActiveStatementFlags.PartiallyExecuted, unmappedDocumentId: document1.Id);
mockEncService.GetBaseActiveStatementSpansImpl = (solution, documentIds) =>
{
AssertEx.Equal(new[] { document1.Id }, documentIds);
return(ImmutableArray.Create(ImmutableArray.Create(activeStatementSpan1)));
};
var baseActiveSpans = await sessionProxy.GetBaseActiveStatementSpansAsync(localWorkspace.CurrentSolution, ImmutableArray.Create(document1.Id), CancellationToken.None).ConfigureAwait(false);
Assert.Equal(activeStatementSpan1, baseActiveSpans.Single().Single());
// GetDocumentActiveStatementSpans
mockEncService.GetAdjustedActiveStatementSpansImpl = (document, activeStatementSpanProvider) =>
{
Assert.Equal("test.cs", document.Name);
AssertEx.Equal(activeSpans1, activeStatementSpanProvider(document.Id, "test.cs", CancellationToken.None).AsTask().Result);
return(ImmutableArray.Create(activeStatementSpan1));
};
var documentActiveSpans = await sessionProxy.GetAdjustedActiveStatementSpansAsync(document1, activeStatementSpanProvider, CancellationToken.None).ConfigureAwait(false);
Assert.Equal(activeStatementSpan1, documentActiveSpans.Single());
// GetDocumentActiveStatementSpans (default array)
mockEncService.GetAdjustedActiveStatementSpansImpl = (document, _) => default;
documentActiveSpans = await sessionProxy.GetAdjustedActiveStatementSpansAsync(document1, activeStatementSpanProvider, CancellationToken.None).ConfigureAwait(false);
Assert.True(documentActiveSpans.IsDefault);
// OnSourceFileUpdatedAsync
called = false;
mockEncService.OnSourceFileUpdatedImpl = updatedDocument =>
{
Assert.Equal(document.Id, updatedDocument.Id);
called = true;
};
await proxy.OnSourceFileUpdatedAsync(document, CancellationToken.None).ConfigureAwait(false);
Assert.True(called);
// EndDebuggingSession
mockEncService.EndDebuggingSessionImpl = (out ImmutableArray <DocumentId> documentsToReanalyze) =>
{
documentsToReanalyze = ImmutableArray.Create(document.Id);
};
await sessionProxy.EndDebuggingSessionAsync(solution, diagnosticUpdateSource, mockDiagnosticService, CancellationToken.None).ConfigureAwait(false);
VerifyReanalyzeInvocation(ImmutableArray.Create(document.Id));
Assert.Equal(1, emitDiagnosticsClearedCount);
emitDiagnosticsClearedCount = 0;
Assert.Empty(emitDiagnosticsUpdated);
}
public VSTypeScriptPullDiagnosticHandlerProvider(
IDiagnosticService diagnosticService,
IDiagnosticAnalyzerService analyzerService,
EditAndContinueDiagnosticUpdateSource editAndContinueDiagnosticUpdateSource) : base(diagnosticService, analyzerService, editAndContinueDiagnosticUpdateSource)
{
}
public VSTypeScriptWorkspacePullDiagnosticHandler(
IDiagnosticAnalyzerService analyzerService,
EditAndContinueDiagnosticUpdateSource editAndContinueDiagnosticUpdateSource,
IGlobalOptionService globalOptions) : base(analyzerService, editAndContinueDiagnosticUpdateSource, globalOptions)
{
}
public WorkspacePullDiagnosticHandler(IDiagnosticService diagnosticService, EditAndContinueDiagnosticUpdateSource editAndContinueDiagnosticUpdateSource)
: base(diagnosticService, editAndContinueDiagnosticUpdateSource)
{
}
public WorkspacePullDiagnosticHandler(IDiagnosticService diagnosticService, EditAndContinueDiagnosticUpdateSource editAndContinueDiagnosticUpdateSource, IGlobalOptionService globalOptions)
: base(diagnosticService, editAndContinueDiagnosticUpdateSource, globalOptions)
{
}
public void ReportDiagnostics()
{
var source = new EditAndContinueDiagnosticUpdateSource();
var updates = new List <string>();
var srcC1 = "class C1 {}";
var srcC2 = "class C2 {}";
var srcD1 = "class D1 {}";
var srcD2 = "class D2 {}";
var docC1 = new TestHostDocument(srcC1, displayName: "DocC1");
var docC2 = new TestHostDocument(srcC2, displayName: "DocC2");
var docD1 = new TestHostDocument(srcD1, displayName: "DocD1");
var docD2 = new TestHostDocument(srcD2, displayName: "DocD2");
var workspace = new TestWorkspace();
source.DiagnosticsUpdated += (object sender, DiagnosticsUpdatedArgs e) =>
{
var diagnostics = e.GetPushDiagnostics(workspace, InternalDiagnosticsOptions.NormalDiagnosticMode);
updates.Add($"{e.Kind} p={e.ProjectId} d={e.DocumentId}: {string.Join(",", diagnostics.Select(d => d.Id.ToString()))}");
};
var projC = new TestHostProject(workspace, "ProjC");
projC.AddDocument(docC1);
projC.AddDocument(docC2);
var projD = new TestHostProject(workspace, "ProjD");
projD.AddDocument(docD1);
projD.AddDocument(docD2);
workspace.AddTestProject(projC);
workspace.AddTestProject(projD);
var treeC1 = workspace.CurrentSolution.GetDocument(docC1.Id).GetSyntaxTreeAsync().Result;
var treeC2 = workspace.CurrentSolution.GetDocument(docC2.Id).GetSyntaxTreeAsync().Result;
var treeD1 = workspace.CurrentSolution.GetDocument(docD1.Id).GetSyntaxTreeAsync().Result;
var treeD2 = workspace.CurrentSolution.GetDocument(docD2.Id).GetSyntaxTreeAsync().Result;
var diagnostics = new[]
{
Diagnostic.Create(new DiagnosticDescriptor("TST0001", "title1", "message1", "category", DiagnosticSeverity.Error, true), Location.Create(treeC1, new TextSpan(1, 1))),
Diagnostic.Create(new DiagnosticDescriptor("TST0002", "title2", "message2", "category", DiagnosticSeverity.Error, true), Location.Create(treeC1, new TextSpan(1, 2))),
Diagnostic.Create(new DiagnosticDescriptor("TST0003", "title3", "message3", "category", DiagnosticSeverity.Error, true), Location.Create(treeD1, new TextSpan(1, 2))),
Diagnostic.Create(new DiagnosticDescriptor("TST0004", "title4", "message4", "category", DiagnosticSeverity.Error, true), Location.Create(treeD2, new TextSpan(1, 2))),
Diagnostic.Create(new DiagnosticDescriptor("TST0005", "title5", "message5", "category", DiagnosticSeverity.Error, true), Location.None),
};
updates.Clear();
source.ReportDiagnostics(workspace, workspace.CurrentSolution, projC.Id, diagnostics);
AssertEx.Equal(new[]
{
$"DiagnosticsCreated p={projC.Id} d={docC1.Id}: TST0001,TST0002",
$"DiagnosticsCreated p={projC.Id} d={docD1.Id}: TST0003",
$"DiagnosticsCreated p={projC.Id} d={docD2.Id}: TST0004",
$"DiagnosticsCreated p={projC.Id} d=: TST0005"
}, updates);
updates.Clear();
source.ReportDiagnostics(workspace, workspace.CurrentSolution, projD.Id, diagnostics);
AssertEx.Equal(new[]
{
$"DiagnosticsCreated p={projD.Id} d={docC1.Id}: TST0001,TST0002",
$"DiagnosticsCreated p={projD.Id} d={docD1.Id}: TST0003",
$"DiagnosticsCreated p={projD.Id} d={docD2.Id}: TST0004",
$"DiagnosticsCreated p={projD.Id} d=: TST0005"
}, updates);
updates.Clear();
source.ReportDiagnostics(workspace, workspace.CurrentSolution, null, diagnostics);
AssertEx.Equal(new[]
{
$"DiagnosticsCreated p= d={docC1.Id}: TST0001,TST0002",
$"DiagnosticsCreated p= d={docD1.Id}: TST0003",
$"DiagnosticsCreated p= d={docD2.Id}: TST0004",
$"DiagnosticsCreated p= d=: TST0005"
}, updates);
}
public void ReportDiagnostics()
{
var service = new DiagnosticService(
AsynchronousOperationListenerProvider.NullProvider, Array.Empty <Lazy <IEventListener, EventListenerMetadata> >());
var source = new EditAndContinueDiagnosticUpdateSource(service);
var updates = new List <string>();
source.DiagnosticsUpdated += (object sender, DiagnosticsUpdatedArgs e) =>
{
updates.Add($"{e.Kind} p={e.ProjectId} d={e.DocumentId}: {string.Join(",", e.Diagnostics.Select(d => d.Id.ToString()))}");
};
var id = new object();
var srcC1 = "class C1 {}";
var srcC2 = "class C2 {}";
var srcD1 = "class D1 {}";
var srcD2 = "class D2 {}";
var docC1 = new TestHostDocument(srcC1, displayName: "DocC1");
var docC2 = new TestHostDocument(srcC2, displayName: "DocC2");
var docD1 = new TestHostDocument(srcD1, displayName: "DocD1");
var docD2 = new TestHostDocument(srcD2, displayName: "DocD2");
var workspace = new TestWorkspace();
var projC = new TestHostProject(workspace, "ProjC");
projC.AddDocument(docC1);
projC.AddDocument(docC2);
var projD = new TestHostProject(workspace, "ProjD");
projD.AddDocument(docD1);
projD.AddDocument(docD2);
workspace.AddTestProject(projC);
workspace.AddTestProject(projD);
var treeC1 = workspace.CurrentSolution.GetDocument(docC1.Id).GetSyntaxTreeAsync().Result;
var treeC2 = workspace.CurrentSolution.GetDocument(docC2.Id).GetSyntaxTreeAsync().Result;
var treeD1 = workspace.CurrentSolution.GetDocument(docD1.Id).GetSyntaxTreeAsync().Result;
var treeD2 = workspace.CurrentSolution.GetDocument(docD2.Id).GetSyntaxTreeAsync().Result;
var diagnostics = new[]
{
Diagnostic.Create(new DiagnosticDescriptor("TST0001", "title1", "message1", "category", DiagnosticSeverity.Error, true), Location.Create(treeC1, new TextSpan(1, 1))),
Diagnostic.Create(new DiagnosticDescriptor("TST0002", "title2", "message2", "category", DiagnosticSeverity.Error, true), Location.Create(treeC1, new TextSpan(1, 2))),
Diagnostic.Create(new DiagnosticDescriptor("TST0003", "title3", "message3", "category", DiagnosticSeverity.Error, true), Location.Create(treeD1, new TextSpan(1, 2))),
Diagnostic.Create(new DiagnosticDescriptor("TST0004", "title4", "message4", "category", DiagnosticSeverity.Error, true), Location.Create(treeD2, new TextSpan(1, 2))),
};
updates.Clear();
var actual = source.ReportDiagnostics(id, workspace.CurrentSolution, projC.Id, diagnostics);
AssertEx.Equal(new[] { docC1.Id }, actual);
AssertEx.Equal(new[]
{
$"DiagnosticsCreated p={projC.Id} d={docC1.Id}: TST0001,TST0002",
$"DiagnosticsCreated p={projC.Id} d={docD1.Id}: TST0003",
$"DiagnosticsCreated p={projC.Id} d={docD2.Id}: TST0004"
}, updates);
updates.Clear();
actual = source.ReportDiagnostics(id, workspace.CurrentSolution, projD.Id, diagnostics);
AssertEx.SetEqual(new[] { docD1.Id, docD2.Id }, actual);
AssertEx.Equal(new[]
{
$"DiagnosticsCreated p={projD.Id} d={docC1.Id}: TST0001,TST0002",
$"DiagnosticsCreated p={projD.Id} d={docD1.Id}: TST0003",
$"DiagnosticsCreated p={projD.Id} d={docD2.Id}: TST0004"
}, updates);
}
public WorkspacePullDiagnosticHandler(WellKnownLspServerKinds serverKind, IDiagnosticService diagnosticService, EditAndContinueDiagnosticUpdateSource editAndContinueDiagnosticUpdateSource)
: base(serverKind, diagnosticService, editAndContinueDiagnosticUpdateSource)
{
}
