public void FieldCtorArg(Search search)
{
var testCode = @"
namespace RoslynSandbox
{
internal class Foo
{
private readonly int value;
internal Foo(int arg)
{
this.value = arg;
}
}
}";
var syntaxTree = CSharpSyntaxTree.ParseText(testCode);
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.FindAssignmentExpression("this.value = arg").Right;
var ctor = syntaxTree.FindConstructorDeclaration("Foo(int arg)");
var arg = semanticModel.GetSymbolSafe(value, CancellationToken.None);
Assert.AreEqual(true, AssignmentWalker.FirstWith(arg, ctor, search, semanticModel, CancellationToken.None, out var result));
Assert.AreEqual("this.value = arg", result?.ToString());
}
public void FieldCtorArgInNested(Search search)
{
var testCode = @"
namespace RoslynSandbox
{
using System.IO;
internal class Foo
{
private StreamReader reader;
internal Foo(Stream stream)
{
this.reader = new StreamReader(stream);
}
}
}";
var syntaxTree = CSharpSyntaxTree.ParseText(testCode);
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.FindBestMatch <ParameterSyntax>("stream");
var ctor = syntaxTree.FindConstructorDeclaration("Foo(Stream stream)");
var symbol = semanticModel.GetDeclaredSymbol(value, CancellationToken.None);
Assert.AreEqual(true, AssignmentWalker.FirstWith(symbol, ctor, search, semanticModel, CancellationToken.None, out var result));
Assert.AreEqual("this.reader = new StreamReader(stream)", result?.ToString());
}
public void FieldInPropertyExpressionBody(Search search)
{
var testCode = @"
namespace RoslynSandbox
{
internal class Foo
{
private int number;
internal Foo()
{
var i = this.Number;
}
public int Number => this.number = 3;
}
}";
var syntaxTree = CSharpSyntaxTree.ParseText(testCode);
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.FindMemberAccessExpression("this.number");
var ctor = syntaxTree.FindConstructorDeclaration("Foo()");
AssignmentExpressionSyntax result;
var field = semanticModel.GetSymbolSafe(value, CancellationToken.None);
if (search == Search.Recursive)
{
Assert.AreEqual(true, AssignmentWalker.FirstForSymbol(field, ctor, Search.Recursive, semanticModel, CancellationToken.None, out result));
Assert.AreEqual("this.number = 3", result?.ToString());
}
else
{
Assert.AreEqual(false, AssignmentWalker.FirstForSymbol(field, ctor, Search.TopLevel, semanticModel, CancellationToken.None, out result));
}
}
public static int RightSideOfAssignmentCount(ISymbol variable,
BlockSyntax block,
SemanticModel semanticModel,
CancellationToken cancellationToken)
{
int count = 0;
using (var walker = AssignmentWalker.Borrow(block, Search.TopLevel, semanticModel, cancellationToken))
{
foreach (AssignmentExpressionSyntax assignment in walker.Assignments)
{
var right = semanticModel.GetSymbolSafe(CastUtils.UnWrapCast(assignment.Right), cancellationToken);
if (right != null && right.Equals(variable))
{
count++;
}
}
}
using (var walker = VariableDeclarationWalker.Borrow(block, Search.TopLevel, semanticModel, cancellationToken))
{
foreach (VariableDeclaratorSyntax delc in walker.Declarations)
{
var rightSymbol = semanticModel.GetSymbolSafe(CastUtils.UnWrapCast(delc.Initializer.Value), cancellationToken);
if (SymbolComparer.Equals(variable, rightSymbol))
{
count++;
}
}
}
return(count);
}
private static void CollectAssignedStructParameters([NotNull][ItemNotNull] ICollection <IParameterSymbol> parameters,
[NotNull] IOperation bodyOperation, [NotNull] DiagnosticCollector collector)
{
var walker = new AssignmentWalker(parameters);
walker.Visit(bodyOperation);
foreach (IParameterSymbol parameter in walker.ParametersAssigned)
{
collector.Add(Diagnostic.Create(Rule, parameter.Locations[0], parameter.Name));
}
}
public static void ProcessLeftSideOfAssignment(ISymbol variable, BlockSyntax block, SemanticModel semanticModel, CancellationToken cancellationToken, RefCounterStatus status)
{
List <AssignmentExpressionSyntax> rc = new List <AssignmentExpressionSyntax>();
using (var walker = AssignmentWalker.Borrow(block, Search.TopLevel, semanticModel, cancellationToken))
{
foreach (AssignmentExpressionSyntax assignment in walker.Assignments)
{
var sym = ModelExtensions.GetSymbolInfo(semanticModel, assignment.Left, cancellationToken);
if (variable.Equals(sym.Symbol))
{
AssignmentUtils.CalcAssignmentValue(assignment.Right, block, semanticModel, cancellationToken, status);
}
}
}
}
public void FieldWithCtorArgViaProperty(Search search)
{
var testCode = @"
namespace RoslynSandbox
{
internal class Foo
{
private int number;
internal Foo(int arg)
{
this.Number = arg;
}
public int Number
{
get { return this.number; }
set { this.number = value; }
}
}
}";
var syntaxTree = CSharpSyntaxTree.ParseText(testCode);
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.FindBestMatch <ParameterSyntax>("arg");
var ctor = syntaxTree.FindConstructorDeclaration("Foo(int arg)");
AssignmentExpressionSyntax result;
var symbol = semanticModel.GetDeclaredSymbolSafe(value, CancellationToken.None);
if (search == Search.Recursive)
{
Assert.AreEqual(true, AssignmentWalker.FirstWith(symbol, ctor, Search.Recursive, semanticModel, CancellationToken.None, out result));
Assert.AreEqual("this.Number = arg", result?.ToString());
}
else
{
Assert.AreEqual(false, AssignmentWalker.FirstForSymbol(symbol, ctor, Search.TopLevel, semanticModel, CancellationToken.None, out result));
}
}
public void ChainedCtorArg(Search search)
{
var testCode = @"
namespace RoslynSandbox
{
internal class Foo
{
private readonly int value;
public Foo(int arg)
: this(arg, 1)
{
}
internal Foo(int chainedArg, int _)
{
this.value = chainedArg;
}
}
}";
var syntaxTree = CSharpSyntaxTree.ParseText(testCode);
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.FindBestMatch <ParameterSyntax>("arg");
var ctor = syntaxTree.FindConstructorDeclaration("Foo(int arg)");
AssignmentExpressionSyntax result;
var symbol = semanticModel.GetDeclaredSymbolSafe(value, CancellationToken.None);
if (search == Search.Recursive)
{
Assert.AreEqual(true, AssignmentWalker.FirstWith(symbol, ctor, Search.Recursive, semanticModel, CancellationToken.None, out result));
Assert.AreEqual("this.value = chainedArg", result?.ToString());
}
else
{
Assert.AreEqual(false, AssignmentWalker.FirstWith(symbol, ctor, Search.TopLevel, semanticModel, CancellationToken.None, out result));
}
}
