public static void LocalAssignedWithChainedOutParameter(string code, string expected)
{
var syntaxTree = CSharpSyntaxTree.ParseText(@"
namespace N
{
internal class C
{
internal C()
{
int value = 0;
var temp1 = value;
Assign1(out value, 1);
var temp2 = value;
}
internal static void Assign1(out int value1, int arg1)
{
Assign2(out value1, arg1);
}
internal static void Assign2(out int value2, int arg2)
{
value2 = arg2;
}
}
}");
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.FindEqualsValueClause(code).Value;
using var assignedValues = AssignedValueWalker.Borrow(value, semanticModel, CancellationToken.None);
var actual = string.Join(", ", assignedValues);
Assert.AreEqual(expected, actual);
}
public void FieldAssignedInLambdaCtor()
{
var syntaxTree = CSharpSyntaxTree.ParseText(@"
namespace RoslynSandbox
{
using System;
public class Foo
{
private int value;
public Foo()
{
Console.CancelKeyPress += (o, e) =>
{
this.value = 1;
};
}
}
}");
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.FindAssignmentExpression("this.value = 1").Left;
using (var assignedValues = AssignedValueWalker.Borrow(value, semanticModel, CancellationToken.None))
{
Assert.AreEqual("1", assignedValues.Single().ToString());
}
}
public void FieldCtorArgThenIdMethod(string code, string expected)
{
var syntaxTree = CSharpSyntaxTree.ParseText(@"
namespace RoslynSandbox
{
internal class Foo
{
private readonly int value;
internal Foo(int arg)
{
var temp1 = this.value;
this.value = Id(arg);
var temp2 = this.value;
}
internal void Bar(int arg)
{
var temp3 = this.value;
}
private static T Id<T>(T genericArg) => genericArg;
}
}");
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.FindEqualsValueClause(code).Value;
using (var assignedValues = AssignedValueWalker.Borrow(value, semanticModel, CancellationToken.None))
{
var actual = string.Join(", ", assignedValues);
Assert.AreEqual(expected, actual);
}
}
public void InitializedInChainedWithLiteralGeneric(string code, string expected)
{
var syntaxTree = CSharpSyntaxTree.ParseText(@"
internal class Foo<T>
{
internal Foo()
{
this.Value = 2;
}
internal Foo(string text)
: this()
{
this.Value = 3;
var temp1 = this.Value;
this.Value = 4;
}
public int Value { get; set; } = 1;
internal void Bar()
{
var temp2 = this.Value;
}
}");
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.EqualsValueClause(code).Value;
using (var assignedValues = AssignedValueWalker.Borrow(value, semanticModel, CancellationToken.None))
{
var actual = string.Join(", ", assignedValues);
Assert.AreEqual(expected, actual);
}
}
public void LocalAssignedWithOutParameterGeneric()
{
var syntaxTree = CSharpSyntaxTree.ParseText(@"
internal class Foo<T>
{
internal Foo()
{
T value;
Assign(out value);
var temp = value;
}
internal void Assign(out T outValue)
{
outValue = default(T);
}
}");
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.FindEqualsValueClause("var temp = value;").Value;
using (var pooled = AssignedValueWalker.Borrow(value, semanticModel, CancellationToken.None))
{
var actual = string.Join(", ", pooled);
#pragma warning disable GU0006 // Use nameof.
Assert.AreEqual("value", actual);
#pragma warning restore GU0006 // Use nameof.
}
}
public void LambdaClosure(string code, string expected)
{
var syntaxTree = CSharpSyntaxTree.ParseText(@"
namespace RoslynSandbox
{
using System;
public class Foo
{
public Foo()
{
int value = 1;
Console.CancelKeyPress += (o, e) =>
{
var temp1 = value;
value = 2;
var temp2 = value;
};
}
}
}");
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.FindEqualsValueClause(code).Value;
using (var assignedValues = AssignedValueWalker.Borrow(value, semanticModel, CancellationToken.None))
{
var actual = string.Join(", ", assignedValues);
Assert.AreEqual(expected, actual);
}
}
public void InitializedWithConstant(string code)
{
var testCode = @"
namespace RoslynSandbox
{
internal class Foo
{
private const int Value = 2;
internal Foo()
{
var value = 1;
var temp = value;
}
}
}";
testCode = testCode.AssertReplace("1", code);
var syntaxTree = CSharpSyntaxTree.ParseText(testCode);
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.EqualsValueClause("var temp = value;").Value;
using (var assignedValues = AssignedValueWalker.Borrow(value, semanticModel, CancellationToken.None))
{
var actual = string.Join(", ", assignedValues);
Assert.AreEqual(code, actual);
}
}
public static void InitializedInBaseCtorWithDefaultGenericSimple()
{
var syntaxTree = CSharpSyntaxTree.ParseText(@"
namespace N
{
internal class Base<T>
{
protected readonly T value;
internal Base()
{
this.value = default(T);
}
}
internal class C : Base<int>
{
internal C()
{
var temp = this.value;
}
}
}");
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.FindEqualsValueClause("var temp = this.value;").Value;
using var assignedValues = AssignedValueWalker.Borrow(value, semanticModel, CancellationToken.None);
var actual = string.Join(", ", assignedValues);
Assert.AreEqual("default(T)", actual);
}
public static void InitializedDictionaryAfterAdd(string code, string expected)
{
var syntaxTree = CSharpSyntaxTree.ParseText(@"
namespace N
{
using System.Collections.Generic;
internal class C
{
internal C()
{
var ints = new Dictionary<int, int>
{
{ 1, 1 },
{ 2, 2 },
};
var temp1 = ints[0];
ints.Add(3, 3);
var temp2 = ints[0];
}
}
}");
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.FindEqualsValueClause(code)
.Value;
using var assignedValues = AssignedValueWalker.Borrow(value, semanticModel, CancellationToken.None);
var actual = string.Join(", ", assignedValues);
Assert.AreEqual(expected, actual);
}
public void LocalAssignedWithOutParameterSimple()
{
var syntaxTree = CSharpSyntaxTree.ParseText(@"
internal class Foo
{
internal Foo()
{
int value;
Assign(out value, 1);
var temp = value;
}
internal void Assign(out int outValue, int arg)
{
outValue = arg;
}
}");
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.FindEqualsValueClause("var temp = value").Value;
using (var pooled = AssignedValueWalker.Borrow(value, semanticModel, CancellationToken.None))
{
var actual = string.Join(", ", pooled);
Assert.AreEqual("1", actual);
}
}
public void AutoPropertyGetSetAssignedInCtor(string code, string expected)
{
var syntaxTree = CSharpSyntaxTree.ParseText(@"
public sealed class Foo
{
public Foo()
{
var temp1 = this.Bar;
this.Bar = 2;
var temp2 = this.Bar;
}
public int Bar { get; set; } = 1;
public void Meh()
{
var temp3 = this.Bar;
}
}");
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.FindEqualsValueClause(code).Value;
using (var pooled = AssignedValueWalker.Borrow(value, semanticModel, CancellationToken.None))
{
var actual = string.Join(", ", pooled);
Assert.AreEqual(expected, actual);
}
}
public static void GenericOut()
{
var syntaxTree = CSharpSyntaxTree.ParseText(@"
namespace N
{
public sealed class C
{
public T M<T>(out T t1)
{
return M(0, out t1);
}
public T M<T>(int _, out T t2)
{
t2 = default;
return default;
}
}
}");
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var argument = syntaxTree.FindArgument("t1");
using var assignedValues = AssignedValueWalker.Borrow(argument.Expression, semanticModel, CancellationToken.None);
var actual = string.Join(", ", assignedValues);
Assert.AreEqual("default", actual);
}
public static void LambdaInCtor(string code, string expected)
{
var syntaxTree = CSharpSyntaxTree.ParseText(@"
namespace N
{
using System;
internal class C
{
private int value;
public C()
{
var temp1 = this.value;
this.Meh += (o, e) => this.value = 1;
var temp2 = this.value;
}
public event EventHandler Meh;
internal void M()
{
var temp3 = this.value;
}
}
}");
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.FindEqualsValueClause(code).Value;
using var assignedValues = AssignedValueWalker.Borrow(value, semanticModel, CancellationToken.None);
var actual = string.Join(", ", assignedValues);
Assert.AreEqual(expected, actual);
}
public static void RecursiveOut()
{
var syntaxTree = CSharpSyntaxTree.ParseText(@"
namespace N
{
internal class C
{
internal void M()
{
int value;
M(1.0, out value);
var temp = value;
}
private static bool M(double foo, out int result)
{
result = 0;
return M(3.0, out result);
}
}
}");
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.FindEqualsValueClause("var temp = value").Value;
using var assignedValues = AssignedValueWalker.Borrow(value, semanticModel, CancellationToken.None);
Assert.AreEqual("0, result", string.Join(", ", assignedValues));
}
public static void BackingFieldPrivateSetSimple()
{
var syntaxTree = CSharpSyntaxTree.ParseText(@"
namespace N
{
public sealed class C
{
private int p;
public int P
{
get { return this.p; }
private set { this.p = value; }
}
public void M()
{
var temp = this.p;
}
}
}");
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.FindEqualsValueClause("var temp = this.p").Value;
using var assignedValues = AssignedValueWalker.Borrow(value, semanticModel, CancellationToken.None);
var actual = string.Join(", ", assignedValues);
Assert.AreEqual(string.Empty, actual);
}
public void FieldCtorArgSimple(string code, string expected)
{
var syntaxTree = CSharpSyntaxTree.ParseText(@"
internal class Foo
{
private readonly int value;
internal Foo(int arg)
{
var temp1 = this.value;
this.value = arg;
var temp2 = this.value;
}
internal void Bar(int arg)
{
var temp3 = this.value;
}
}");
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.FindEqualsValueClause(code).Value;
using (var pooled = AssignedValueWalker.Borrow(value, semanticModel, CancellationToken.None))
{
var actual = string.Join(", ", pooled);
Assert.AreEqual(expected, actual);
}
}
public static void AutoPropertyGetOnlyAssignedInCtor(string code, string expected)
{
var syntaxTree = CSharpSyntaxTree.ParseText(@"
namespace N
{
public sealed class C
{
public C()
{
var temp1 = this.P;
this.P = 2;
var temp2 = this.P;
}
public int P { get; } = 1;
public void M()
{
var temp3 = this.P;
}
}
}");
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.FindEqualsValueClause(code).Value;
using var assignedValues = AssignedValueWalker.Borrow(value, semanticModel, CancellationToken.None);
var actual = string.Join(", ", assignedValues);
Assert.AreEqual(expected, actual);
}
public void BackingFieldPublicSetSimple()
{
var syntaxTree = CSharpSyntaxTree.ParseText(@"
namespace RoslynSandbox
{
public sealed class Foo
{
private int bar;
public int Bar
{
get { return this.bar; }
set { this.bar = value; }
}
public void Meh()
{
var temp = this.bar;
}
}
}");
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.EqualsValueClause("var temp = this.bar").Value;
using (var assignedValues = AssignedValueWalker.Borrow(value, semanticModel, CancellationToken.None))
{
var actual = string.Join(", ", assignedValues);
#pragma warning disable GU0006 // Use nameof.
Assert.AreEqual("value", actual);
#pragma warning restore GU0006 // Use nameof.
}
}
public void NotInitialized(string code, string expected)
{
var syntaxTree = CSharpSyntaxTree.ParseText(@"
namespace RoslynSandbox
{
internal class Foo
{
internal Foo()
{
int value;
var temp1 = value;
value = 1;
var temp2 = value;
}
}
}");
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.FindEqualsValueClause(code).Value;
using (var assignedValues = AssignedValueWalker.Borrow(value, semanticModel, CancellationToken.None))
{
var actual = string.Join(", ", assignedValues);
Assert.AreEqual(expected, actual);
}
}
public void LocalAssignedWithOutParameterGeneric()
{
var syntaxTree = CSharpSyntaxTree.ParseText(@"
internal class Foo<T>
{
internal Foo()
{
T value;
Assign(out value);
var temp = value;
}
internal void Assign(out T outValue)
{
outValue = default(T);
}
}");
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.FindEqualsValueClause("var temp = value;").Value;
using (var assignedValues = AssignedValueWalker.Borrow(value, semanticModel, CancellationToken.None))
{
Assert.AreEqual("default(T)", assignedValues.Single().ToString());
}
}
public void FieldInitializedlWithLiteralAndAssignedInCtor(string code, string expected)
{
var syntaxTree = CSharpSyntaxTree.ParseText(@"
internal class Foo
{
private readonly int value = 1;
private readonly int temp1 = this.value;
internal Foo()
{
var temp1 = this.value;
var temp2 = this.temp1;
this.value = 2;
var temp3 = this.value;
var temp4 = this.temp1;
}
internal void Bar()
{
var temp5 = this.value;
var temp6 = this.temp1;
}
}");
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.EqualsValueClause(code).Value;
using (var assignedValues = AssignedValueWalker.Borrow(value, semanticModel, CancellationToken.None))
{
var actual = string.Join(", ", assignedValues);
Assert.AreEqual(expected, actual);
}
}
public void RefBeforeOut()
{
var syntaxTree = CSharpSyntaxTree.ParseText(@"
namespace RoslynSandbox
{
internal class Foo
{
internal Foo()
{
int value = 0;
Assign(ref value, out value);
var temp = value;
}
internal void Assign(ref int refValue, out int outValue)
{
outValue = 2;
refValue = 1;
}
}
}");
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.FindEqualsValueClause("var temp = value").Value;
using (var assignedValues = AssignedValueWalker.Borrow(value, semanticModel, CancellationToken.None))
{
var actual = string.Join(", ", assignedValues);
Assert.AreEqual("0, 1, 2", actual);
}
}
public void LocalAssignedWithRefParameter(string code, string expected)
{
var syntaxTree = CSharpSyntaxTree.ParseText(@"
internal class Foo
{
internal Foo()
{
int value;
var temp1 = value;
Assign(ref value);
var temp2 = value;
}
internal void Assign(ref int value)
{
value = 1;
}
}");
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.FindEqualsValueClause(code).Value;
using (var pooled = AssignedValueWalker.Borrow(value, semanticModel, CancellationToken.None))
{
var actual = string.Join(", ", pooled);
Assert.AreEqual(expected, actual);
}
}
public void RecursiveOut()
{
var syntaxTree = CSharpSyntaxTree.ParseText(@"
namespace RoslynSandbox
{
internal class Foo
{
internal void Bar()
{
int value;
RecursiveOut(1.0, out value);
var temp = value;
}
public static bool RecursiveOut(double foo, out int value)
{
value = 0;
return RecursiveOut(3.0, out value);
}
}
}");
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.FindEqualsValueClause("var temp = value").Value;
using (var assignedValues = AssignedValueWalker.Borrow(value, semanticModel, CancellationToken.None))
{
var actual = string.Join(", ", assignedValues);
Assert.AreEqual("0", actual);
}
}
public void InitializedListOfIntIndexerAfterAddItem(string code, string expected)
{
var syntaxTree = CSharpSyntaxTree.ParseText(@"
namespace RoslynSandbox
{
using System.Collections.Generic;
internal class Foo
{
internal Foo()
{
var ints = new List<int> { 1, 2 };
var temp1 = ints[0];
ints.Add(3);
var temp2 = ints[0];
}
}
}");
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.FindEqualsValueClause(code)
.Value;
using (var assignedValues = AssignedValueWalker.Borrow(value, semanticModel, CancellationToken.None))
{
var actual = string.Join(", ", assignedValues);
Assert.AreEqual(expected, actual);
}
}
public void LocalAssignedWithOutParameterOtherClassElvis()
{
var syntaxTree = CSharpSyntaxTree.ParseText(@"
class Foo
{
Foo(Bar bar)
{
int value;
bar?.Assign(out value, 1);
var temp = value;
}
}
class Bar
{
internal void Assign(out int outValue, int arg)
{
outValue = arg;
}
}");
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.FindEqualsValueClause("var temp = value").Value;
using (var assignedValues = AssignedValueWalker.Borrow(value, semanticModel, CancellationToken.None))
{
Assert.AreEqual("1", assignedValues.Single().ToString());
}
}
public void FieldPublicCtorFactory(string code, string expected)
{
var syntaxTree = CSharpSyntaxTree.ParseText(@"
namespace RoslynSandbox
{
internal class Foo
{
public int value = 1;
public Foo(int ctorArg)
{
var temp1 = this.value;
this.value = ctorArg;
var temp2 = this.value;
}
internal static Foo Create()
{
return new Foo(2);
}
}
}");
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.FindEqualsValueClause(code).Value;
using (var assignedValues = AssignedValueWalker.Borrow(value, semanticModel, CancellationToken.None))
{
var actual = string.Join(", ", assignedValues);
Assert.AreEqual(expected, actual);
}
}
public void InitializedElementStyleDictionaryIndexer(string code, string expected)
{
var syntaxTree = CSharpSyntaxTree.ParseText(@"
namespace RoslynSandbox
{
using System.Collections.Generic;
internal class Foo
{
internal Foo()
{
var ints = new Dictionary<int, int>
{
[1] = 1,
[2] = 2,
};
var temp1 = ints[0];
ints[3] = 3;
var temp2 = ints[0];
}
}
}");
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.FindEqualsValueClause(code)
.Value;
using (var pooled = AssignedValueWalker.Borrow(value, semanticModel, CancellationToken.None))
{
var actual = string.Join(", ", pooled);
Assert.AreEqual(expected, actual);
}
}
public void AbstractGenericInitializedInBaseCtorSimple()
{
var syntaxTree = CSharpSyntaxTree.ParseText(@"
namespace RoslynSandbox
{
public abstract class FooBase<T>
{
protected FooBase()
{
this.Value = default(T);
}
public abstract T Value { get; set; }
}
public class Foo : FooBase<int>
{
public Foo()
{
var temp = this.Value;
}
public override int Value { get; set; }
}
}");
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.FindEqualsValueClause("var temp = this.Value;").Value;
using (var assignedValues = AssignedValueWalker.Borrow(value, semanticModel, CancellationToken.None))
{
var actual = string.Join(", ", assignedValues);
Assert.AreEqual("default(T)", actual);
}
}
public static void OutParameterCachedAndAssigned()
{
var syntaxTree = CSharpSyntaxTree.ParseText(@"
namespace N
{
using System.Collections.Generic;
public static class C
{
public static readonly Dictionary<int, int> Map = new Dictionary<int, int>();
private static bool TryGet(int i, out int result)
{
if (Map.TryGetValue(i, out result))
{
return true;
}
result = 1;
Map.Add(i, result);
return true;
}
}
}");
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.FindParameter("result");
Assert.AreEqual(true, semanticModel.TryGetSymbol(value, CancellationToken.None, out var parameter));
using var assignedValues = AssignedValueWalker.Borrow(parameter, semanticModel, CancellationToken.None);
Assert.AreEqual("result, 1", string.Join(", ", assignedValues));
}
