protected static void AssertContainedInDeclaratorArguments(
SingleVariableDesignationSyntax decl
)
{
Assert.True(
decl.Ancestors()
.OfType <VariableDeclaratorSyntax>()
.First()
.ArgumentList.Contains(decl)
);
}
protected static void VerifyModelForDeclarationField(
SemanticModel model,
SingleVariableDesignationSyntax designation,
bool duplicate,
params IdentifierNameSyntax[] references)
{
var symbol = model.GetDeclaredSymbol(designation);
Assert.Equal(designation.Identifier.ValueText, symbol.Name);
Assert.Equal(SymbolKind.Field, symbol.Kind);
Assert.Equal(designation, symbol.DeclaringSyntaxReferences.Single().GetSyntax());
Assert.Same(symbol, model.GetDeclaredSymbol((SyntaxNode)designation));
var symbols = model.LookupSymbols(designation.SpanStart, name: designation.Identifier.ValueText);
var names = model.LookupNames(designation.SpanStart);
if (duplicate)
{
Assert.True(symbols.Count() > 1);
Assert.Contains(symbol, symbols);
}
else
{
Assert.Same(symbol, symbols.Single());
}
Assert.Contains(designation.Identifier.ValueText, names);
DeclarationPatternSyntax decl = (DeclarationPatternSyntax)designation.Parent;
var local = (FieldSymbol)symbol;
var typeSyntax = decl.Type;
Assert.True(SyntaxFacts.IsInNamespaceOrTypeContext(typeSyntax));
Assert.True(SyntaxFacts.IsInTypeOnlyContext(typeSyntax));
if (typeSyntax.IsVar && local.Type.IsErrorType())
{
Assert.Null(model.GetSymbolInfo(typeSyntax).Symbol);
}
else
{
Assert.Equal(local.Type, model.GetSymbolInfo(typeSyntax).Symbol);
}
var declarator = designation.Ancestors().OfType <VariableDeclaratorSyntax>().FirstOrDefault();
var inFieldDeclaratorArgumentlist = declarator != null && declarator.Parent.Parent.Kind() != SyntaxKind.LocalDeclarationStatement &&
(declarator.ArgumentList?.Contains(designation)).GetValueOrDefault();
// this is a declaration site, not a use site.
Assert.Null(model.GetSymbolInfo(designation).Symbol);
Assert.Null(model.GetSymbolInfo(designation).Symbol);
foreach (var reference in references)
{
var referenceInfo = model.GetSymbolInfo(reference);
symbols = model.LookupSymbols(reference.SpanStart, name: designation.Identifier.ValueText);
if (duplicate)
{
Assert.Null(referenceInfo.Symbol);
Assert.Contains(symbol, referenceInfo.CandidateSymbols);
Assert.True(symbols.Count() > 1);
Assert.Contains(symbol, symbols);
}
else
{
Assert.Same(symbol, referenceInfo.Symbol);
Assert.Same(symbol, symbols.Single());
Assert.Equal(local.Type, model.GetTypeInfo(reference).Type);
}
Assert.True(model.LookupNames(reference.SpanStart).Contains(designation.Identifier.ValueText));
}
if (!inFieldDeclaratorArgumentlist)
{
var dataFlowParent = designation.FirstAncestorOrSelf <ExpressionSyntax>();
if (model.IsSpeculativeSemanticModel)
{
Assert.Throws <NotSupportedException>(() => model.AnalyzeDataFlow(dataFlowParent));
}
else
{
var dataFlow = model.AnalyzeDataFlow(dataFlowParent);
if (dataFlow.Succeeded)
{
Assert.False(dataFlow.VariablesDeclared.Contains(symbol, ReferenceEqualityComparer.Instance));
Assert.False(dataFlow.AlwaysAssigned.Contains(symbol, ReferenceEqualityComparer.Instance));
Assert.False(dataFlow.WrittenInside.Contains(symbol, ReferenceEqualityComparer.Instance));
Assert.False(dataFlow.DataFlowsIn.Contains(symbol, ReferenceEqualityComparer.Instance));
Assert.False(dataFlow.ReadInside.Contains(symbol, ReferenceEqualityComparer.Instance));
Assert.False(dataFlow.DataFlowsOut.Contains(symbol, ReferenceEqualityComparer.Instance));
Assert.False(dataFlow.ReadOutside.Contains(symbol, ReferenceEqualityComparer.Instance));
Assert.False(dataFlow.WrittenOutside.Contains(symbol, ReferenceEqualityComparer.Instance));
}
}
}
}
protected static void AssertContainedInDeclaratorArguments(SingleVariableDesignationSyntax decl)
{
Assert.True(decl.Ancestors().OfType<VariableDeclaratorSyntax>().First().ArgumentList.Contains(decl));
}
protected static void VerifyModelForDeclarationField(
SemanticModel model,
SingleVariableDesignationSyntax designation,
bool duplicate,
params IdentifierNameSyntax[] references)
{
var symbol = model.GetDeclaredSymbol(designation);
Assert.Equal(designation.Identifier.ValueText, symbol.Name);
Assert.Equal(SymbolKind.Field, symbol.Kind);
Assert.Equal(designation, symbol.DeclaringSyntaxReferences.Single().GetSyntax());
Assert.Same(symbol, model.GetDeclaredSymbol((SyntaxNode)designation));
var symbols = model.LookupSymbols(designation.SpanStart, name: designation.Identifier.ValueText);
var names = model.LookupNames(designation.SpanStart);
if (duplicate)
{
Assert.True(symbols.Count() > 1);
Assert.Contains(symbol, symbols);
}
else
{
Assert.Same(symbol, symbols.Single());
}
Assert.Contains(designation.Identifier.ValueText, names);
DeclarationPatternSyntax decl = (DeclarationPatternSyntax)designation.Parent;
var local = (FieldSymbol)symbol;
var typeSyntax = decl.Type;
Assert.True(SyntaxFacts.IsInNamespaceOrTypeContext(typeSyntax));
Assert.True(SyntaxFacts.IsInTypeOnlyContext(typeSyntax));
if (typeSyntax.IsVar && local.Type.IsErrorType())
{
Assert.Null(model.GetSymbolInfo(typeSyntax).Symbol);
}
else
{
Assert.Equal(local.Type, model.GetSymbolInfo(typeSyntax).Symbol);
}
var declarator = designation.Ancestors().OfType<VariableDeclaratorSyntax>().FirstOrDefault();
var inFieldDeclaratorArgumentlist = declarator != null && declarator.Parent.Parent.Kind() != SyntaxKind.LocalDeclarationStatement &&
(declarator.ArgumentList?.Contains(designation)).GetValueOrDefault();
// this is a declaration site, not a use site.
Assert.Null(model.GetSymbolInfo(designation).Symbol);
Assert.Null(model.GetSymbolInfo(designation).Symbol);
foreach (var reference in references)
{
var referenceInfo = model.GetSymbolInfo(reference);
symbols = model.LookupSymbols(reference.SpanStart, name: designation.Identifier.ValueText);
if (duplicate)
{
Assert.Null(referenceInfo.Symbol);
Assert.Contains(symbol, referenceInfo.CandidateSymbols);
Assert.True(symbols.Count() > 1);
Assert.Contains(symbol, symbols);
}
else
{
Assert.Same(symbol, referenceInfo.Symbol);
Assert.Same(symbol, symbols.Single());
Assert.Equal(local.Type, model.GetTypeInfo(reference).Type);
}
Assert.True(model.LookupNames(reference.SpanStart).Contains(designation.Identifier.ValueText));
}
if (!inFieldDeclaratorArgumentlist)
{
var dataFlowParent = designation.FirstAncestorOrSelf<ExpressionSyntax>();
if (model.IsSpeculativeSemanticModel)
{
Assert.Throws<NotSupportedException>(() => model.AnalyzeDataFlow(dataFlowParent));
}
else
{
var dataFlow = model.AnalyzeDataFlow(dataFlowParent);
if (dataFlow.Succeeded)
{
Assert.False(dataFlow.VariablesDeclared.Contains(symbol, ReferenceEqualityComparer.Instance));
Assert.False(dataFlow.AlwaysAssigned.Contains(symbol, ReferenceEqualityComparer.Instance));
Assert.False(dataFlow.WrittenInside.Contains(symbol, ReferenceEqualityComparer.Instance));
Assert.False(dataFlow.DataFlowsIn.Contains(symbol, ReferenceEqualityComparer.Instance));
Assert.False(dataFlow.ReadInside.Contains(symbol, ReferenceEqualityComparer.Instance));
Assert.False(dataFlow.DataFlowsOut.Contains(symbol, ReferenceEqualityComparer.Instance));
Assert.False(dataFlow.ReadOutside.Contains(symbol, ReferenceEqualityComparer.Instance));
Assert.False(dataFlow.WrittenOutside.Contains(symbol, ReferenceEqualityComparer.Instance));
}
}
}
}
