internal static void VerifySemanticDiagnostics(
this EditScript <SyntaxNode> editScript,
ActiveStatementsDescription?activeStatements = null,
TargetFramework[]?targetFrameworks = null,
EditAndContinueCapabilities?capabilities = null,
params RudeEditDiagnosticDescription[] diagnostics)
{
VerifySemantics(
new[] { editScript },
new[] { new DocumentAnalysisResultsDescription(activeStatements: activeStatements, diagnostics: diagnostics) },
targetFrameworks,
capabilities);
}
public DocumentAnalysisResultsDescription(
ActiveStatementsDescription?activeStatements = null,
SemanticEditDescription[]?semanticEdits = null,
RudeEditDiagnosticDescription[]?diagnostics = null)
{
// The test must validate semantic edits, diagnostics or both.
// If neither is specified then assume the expectation is that
// the documents has no edits and no diagnostics.
if (semanticEdits is null && diagnostics is null)
{
SemanticEdits = ImmutableArray <SemanticEditDescription> .Empty;
Diagnostics = ImmutableArray <RudeEditDiagnosticDescription> .Empty;
}
internal static void VerifySemantics(
this EditScript <SyntaxNode>[] editScripts,
ActiveStatementsDescription?activeStatements = null,
TargetFramework[]?targetFrameworks = null,
SemanticEditDescription[]?expectedSemanticEdits = null,
RudeEditDiagnosticDescription[]?expectedDiagnostics = null)
{
foreach (var targetFramework in targetFrameworks ?? new[] { TargetFramework.NetStandard20, TargetFramework.NetCoreApp })
{
new CSharpEditAndContinueTestHelpers(targetFramework).VerifySemantics(
editScripts,
activeStatements,
expectedSemanticEdits,
expectedDiagnostics);
}
}
internal static void VerifySemantics(
this EditScript <SyntaxNode> editScript,
ActiveStatementsDescription?activeStatements = null,
TargetFramework[]?targetFrameworks = null,
IEnumerable <string>?additionalOldSources = null,
IEnumerable <string>?additionalNewSources = null,
SemanticEditDescription[]?expectedSemanticEdits = null,
DiagnosticDescription?expectedDeclarationError = null,
RudeEditDiagnosticDescription[]?expectedDiagnostics = null)
{
foreach (var targetFramework in targetFrameworks ?? new[] { TargetFramework.NetStandard20, TargetFramework.NetCoreApp30 })
{
new CSharpEditAndContinueTestHelpers(targetFramework).VerifySemantics(
editScript,
activeStatements,
additionalOldSources,
additionalNewSources,
expectedSemanticEdits,
expectedDeclarationError,
expectedDiagnostics);
}
}
internal void VerifySemantics(
EditScript <SyntaxNode> editScript,
ActiveStatementsDescription?activeStatements = null,
IEnumerable <string>?additionalOldSources = null,
IEnumerable <string>?additionalNewSources = null,
SemanticEditDescription[]?expectedSemanticEdits = null,
DiagnosticDescription?expectedDeclarationError = null,
RudeEditDiagnosticDescription[]?expectedDiagnostics = null)
{
activeStatements ??= ActiveStatementsDescription.Empty;
var editMap = BuildEditMap(editScript);
var oldRoot = editScript.Match.OldRoot;
var newRoot = editScript.Match.NewRoot;
var oldSource = oldRoot.SyntaxTree.ToString();
var newSource = newRoot.SyntaxTree.ToString();
var oldText = SourceText.From(oldSource);
var newText = SourceText.From(newSource);
IEnumerable <SyntaxTree> oldTrees = new[] { oldRoot.SyntaxTree };
IEnumerable <SyntaxTree> newTrees = new[] { newRoot.SyntaxTree };
if (additionalOldSources != null)
{
oldTrees = oldTrees.Concat(additionalOldSources.Select(s => ParseText(s)));
}
if (additionalOldSources != null)
{
newTrees = newTrees.Concat(additionalNewSources.Select(s => ParseText(s)));
}
var oldCompilation = CreateLibraryCompilation("Old", oldTrees);
var newCompilation = CreateLibraryCompilation("New", newTrees);
var oldModel = oldCompilation.GetSemanticModel(oldRoot.SyntaxTree);
var newModel = newCompilation.GetSemanticModel(newRoot.SyntaxTree);
var oldActiveStatements = activeStatements.OldStatements.AsImmutable();
var updatedActiveMethodMatches = new List <UpdatedMemberInfo>();
var triviaEdits = new List <(SyntaxNode OldNode, SyntaxNode NewNode)>();
var actualLineEdits = new List <LineChange>();
var actualSemanticEdits = new List <SemanticEdit>();
var diagnostics = new List <RudeEditDiagnostic>();
var spanTracker = new TestActiveStatementSpanTracker();
var documentId = DocumentId.CreateNewId(ProjectId.CreateNewId());
var actualNewActiveStatements = new ActiveStatement[activeStatements.OldStatements.Length];
var actualNewExceptionRegions = new ImmutableArray <LinePositionSpan> [activeStatements.OldStatements.Length];
Analyzer.GetTestAccessor().AnalyzeSyntax(
editScript,
editMap,
oldText,
newText,
documentId,
spanTracker,
oldActiveStatements,
actualNewActiveStatements,
actualNewExceptionRegions,
updatedActiveMethodMatches,
diagnostics);
diagnostics.Verify(newSource);
Analyzer.GetTestAccessor().AnalyzeTrivia(
oldText,
newText,
editScript.Match,
editMap,
triviaEdits,
actualLineEdits,
diagnostics,
CancellationToken.None);
diagnostics.Verify(newSource);
Analyzer.GetTestAccessor().AnalyzeSemantics(
editScript,
editMap,
oldText,
oldActiveStatements,
triviaEdits,
updatedActiveMethodMatches,
oldModel,
newModel,
actualSemanticEdits,
diagnostics,
out var firstDeclarationErrorOpt,
CancellationToken.None);
var actualDeclarationErrors = (firstDeclarationErrorOpt != null) ? new[] { firstDeclarationErrorOpt } : Array.Empty <Diagnostic>();
var expectedDeclarationErrors = (expectedDeclarationError != null) ? new[] { expectedDeclarationError } : Array.Empty <DiagnosticDescription>();
actualDeclarationErrors.Verify(expectedDeclarationErrors);
diagnostics.Verify(newSource, expectedDiagnostics);
if (expectedSemanticEdits == null)
{
return;
}
Assert.Equal(expectedSemanticEdits.Length, actualSemanticEdits.Count);
for (var i = 0; i < actualSemanticEdits.Count; i++)
{
var editKind = expectedSemanticEdits[i].Kind;
Assert.Equal(editKind, actualSemanticEdits[i].Kind);
var expectedOldSymbol = (editKind == SemanticEditKind.Update) ? expectedSemanticEdits[i].SymbolProvider(oldCompilation) : null;
var expectedNewSymbol = expectedSemanticEdits[i].SymbolProvider(newCompilation);
var actualOldSymbol = actualSemanticEdits[i].OldSymbol;
var actualNewSymbol = actualSemanticEdits[i].NewSymbol;
Assert.Equal(expectedOldSymbol, actualOldSymbol);
Assert.Equal(expectedNewSymbol, actualNewSymbol);
var expectedSyntaxMap = expectedSemanticEdits[i].SyntaxMap;
var actualSyntaxMap = actualSemanticEdits[i].SyntaxMap;
Assert.Equal(expectedSemanticEdits[i].PreserveLocalVariables, actualSemanticEdits[i].PreserveLocalVariables);
if (expectedSyntaxMap != null)
{
Contract.ThrowIfNull(actualSyntaxMap);
Assert.True(expectedSemanticEdits[i].PreserveLocalVariables);
var newNodes = new List <SyntaxNode>();
foreach (var expectedSpanMapping in expectedSyntaxMap)
{
var newNode = FindNode(newRoot, expectedSpanMapping.Value);
var expectedOldNode = FindNode(oldRoot, expectedSpanMapping.Key);
var actualOldNode = actualSyntaxMap(newNode);
Assert.Equal(expectedOldNode, actualOldNode);
newNodes.Add(newNode);
}
}
else if (!expectedSemanticEdits[i].PreserveLocalVariables)
{
Assert.Null(actualSyntaxMap);
}
}
}
internal void VerifySemantics(
IEnumerable <EditScript <SyntaxNode> > editScripts,
ActiveStatementsDescription?activeStatements = null,
SemanticEditDescription[]?expectedSemanticEdits = null,
RudeEditDiagnosticDescription[]?expectedDiagnostics = null)
{
activeStatements ??= ActiveStatementsDescription.Empty;
var oldTrees = editScripts.Select(editScript => editScript.Match.OldRoot.SyntaxTree).ToArray();
var newTrees = editScripts.Select(editScript => editScript.Match.NewRoot.SyntaxTree).ToArray();
var oldCompilation = CreateLibraryCompilation("Old", oldTrees);
var newCompilation = CreateLibraryCompilation("New", newTrees);
var oldActiveStatements = activeStatements.OldStatements.AsImmutable();
var triviaEdits = new ArrayBuilder <(SyntaxNode OldNode, SyntaxNode NewNode)>();
var actualLineEdits = new ArrayBuilder <SourceLineUpdate>();
var actualSemanticEdits = new ArrayBuilder <SemanticEdit>();
var includeFirstLineInDiagnostics = expectedDiagnostics?.Any(d => d.FirstLine != null) == true;
var actualDiagnosticDescriptions = new ArrayBuilder <RudeEditDiagnosticDescription>();
var actualDeclarationErrors = new ArrayBuilder <Diagnostic>();
var actualNewActiveStatements = ImmutableArray.CreateBuilder <ActiveStatement>(activeStatements.OldStatements.Length);
actualNewActiveStatements.Count = actualNewActiveStatements.Capacity;
var actualNewExceptionRegions = ImmutableArray.CreateBuilder <ImmutableArray <LinePositionSpan> >(activeStatements.OldStatements.Length);
actualNewExceptionRegions.Count = actualNewExceptionRegions.Capacity;
var testAccessor = Analyzer.GetTestAccessor();
foreach (var editScript in editScripts)
{
var oldRoot = editScript.Match.OldRoot;
var newRoot = editScript.Match.NewRoot;
var oldSource = oldRoot.SyntaxTree.ToString();
var newSource = newRoot.SyntaxTree.ToString();
var editMap = BuildEditMap(editScript);
var oldText = SourceText.From(oldSource);
var newText = SourceText.From(newSource);
var oldModel = oldCompilation.GetSemanticModel(oldRoot.SyntaxTree);
var newModel = newCompilation.GetSemanticModel(newRoot.SyntaxTree);
var diagnostics = new ArrayBuilder <RudeEditDiagnostic>();
var updatedActiveMethodMatches = new ArrayBuilder <UpdatedMemberInfo>();
testAccessor.AnalyzeMemberBodiesSyntax(
editScript,
editMap,
oldText,
newText,
oldActiveStatements,
activeStatements.OldTrackingSpans.ToImmutableArrayOrEmpty(),
actualNewActiveStatements,
actualNewExceptionRegions,
updatedActiveMethodMatches,
diagnostics);
testAccessor.ReportTopLevelSynctactiveRudeEdits(diagnostics, editScript, editMap);
testAccessor.AnalyzeTrivia(
oldText,
newText,
editScript.Match,
editMap,
triviaEdits,
actualLineEdits,
diagnostics,
CancellationToken.None);
testAccessor.AnalyzeSemantics(
editScript,
editMap,
oldText,
oldActiveStatements,
triviaEdits,
updatedActiveMethodMatches,
oldModel,
newModel,
actualSemanticEdits,
diagnostics,
CancellationToken.None);
actualDiagnosticDescriptions.AddRange(diagnostics.ToDescription(newSource, includeFirstLineInDiagnostics));
}
actualDiagnosticDescriptions.Verify(expectedDiagnostics);
if (expectedSemanticEdits == null)
{
return;
}
Assert.Equal(expectedSemanticEdits.Length, actualSemanticEdits.Count);
for (var i = 0; i < actualSemanticEdits.Count; i++)
{
var editKind = expectedSemanticEdits[i].Kind;
Assert.Equal(editKind, actualSemanticEdits[i].Kind);
var expectedOldSymbol = (editKind == SemanticEditKind.Update) ? expectedSemanticEdits[i].SymbolProvider(oldCompilation) : null;
var expectedNewSymbol = expectedSemanticEdits[i].SymbolProvider(newCompilation);
var actualOldSymbol = actualSemanticEdits[i].OldSymbol;
var actualNewSymbol = actualSemanticEdits[i].NewSymbol;
Assert.Equal(expectedOldSymbol, actualOldSymbol);
Assert.Equal(expectedNewSymbol, actualNewSymbol);
var expectedSyntaxMap = expectedSemanticEdits[i].SyntaxMap;
var syntaxTreeOrdinal = expectedSemanticEdits[i].SyntaxTreeOrdinal;
var oldRoot = oldTrees[syntaxTreeOrdinal].GetRoot();
var newRoot = newTrees[syntaxTreeOrdinal].GetRoot();
var actualSyntaxMap = actualSemanticEdits[i].SyntaxMap;
Assert.Equal(expectedSemanticEdits[i].PreserveLocalVariables, actualSemanticEdits[i].PreserveLocalVariables);
if (expectedSyntaxMap != null)
{
Contract.ThrowIfNull(actualSyntaxMap);
Assert.True(expectedSemanticEdits[i].PreserveLocalVariables);
foreach (var expectedSpanMapping in expectedSyntaxMap)
{
var newNode = FindNode(newRoot, expectedSpanMapping.Value);
var expectedOldNode = FindNode(oldRoot, expectedSpanMapping.Key);
var actualOldNode = actualSyntaxMap(newNode);
Assert.Equal(expectedOldNode, actualOldNode);
}
}
else if (!expectedSemanticEdits[i].PreserveLocalVariables)
{
Assert.Null(actualSyntaxMap);
}
}
}