public static void Lambda(string expression, ReturnValueSearch search, string expected)
{
var code = @"
namespace N
{
using System;
internal class C
{
internal C()
{
Func<int> temp = () => 1;
}
internal static int StaticCreateIntStatementBody()
{
return 1;
}
}
}".AssertReplace("Func<int> temp = () => 1", expression);
var syntaxTree = CSharpSyntaxTree.ParseText(code);
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.FindEqualsValueClause(expression).Value;
using var returnValues = ReturnValueWalker.Borrow(value, search, semanticModel, CancellationToken.None);
var actual = string.Join(", ", returnValues);
Assert.AreEqual(expected, actual);
}
public static void AwaitSyntaxError(ReturnValueSearch search, string expected)
{
var code = @"
using System.Threading.Tasks;
internal class C
{
internal static async Task M()
{
var text = await CreateAsync().ConfigureAwait(false);
}
internal static async Task<string> CreateAsync()
{
await Task.Delay(0);
return await Task.SyntaxError(() => new string(' ', 1)).ConfigureAwait(false);
}
}";
var syntaxTree = CSharpSyntaxTree.ParseText(code);
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.FindExpression("await CreateAsync().ConfigureAwait(false)");
using var pooled = ReturnValueWalker.Borrow(value, search, semanticModel, CancellationToken.None);
var actual = string.Join(", ", pooled);
Assert.AreEqual(expected, actual);
}
public void AsyncAwaitRecursive(string code, ReturnValueSearch search, string expected)
{
var testCode = @"
namespace RoslynSandbox
{
using System;
using System.Threading.Tasks;
public class Disposable : IDisposable
{
public void Dispose()
{
}
}
internal class Foo
{
internal async Task Bar()
{
var value = await RecursiveAsync();
}
internal static Task<int> RecursiveAsync() => RecursiveAsync();
internal static Task<int> RecursiveAsync(int arg) => RecursiveAsync(arg);
private static async Task<int> RecursiveAsync1(int value)
{
return await RecursiveAsync2(value);
}
private static async Task<int> RecursiveAsync2(int value)
{
return await RecursiveAsync1(value);
}
private static Task<int> RecursiveAsync3(int value)
{
return RecursiveAsync4(value);
}
private static async Task<int> RecursiveAsync4(int value)
{
return await RecursiveAsync3(value);
}
}
}".AssertReplace("var value = await RecursiveAsync()", $"var value = {code}");
var syntaxTree = CSharpSyntaxTree.ParseText(testCode);
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.FindEqualsValueClause(code).Value;
using (var returnValues = ReturnValueWalker.Borrow(value, search, semanticModel, CancellationToken.None))
{
Assert.AreEqual(expected, string.Join(", ", returnValues));
}
}
internal static ReturnValueWalker Borrow(SyntaxNode node, ReturnValueSearch search, SemanticModel semanticModel, CancellationToken cancellationToken)
{
var walker = Borrow(() => new ReturnValueWalker());
walker.search = search;
walker.semanticModel = semanticModel;
walker.cancellationToken = cancellationToken;
walker.Run(node);
return(walker);
}
public void Property(string code, ReturnValueSearch search, string expected)
{
var testCode = @"
namespace RoslynSandbox
{
internal class Foo
{
private readonly int value = 1;
internal Foo()
{
var temp = CalculatedExpressionBody;
}
public int CalculatedExpressionBody => 1;
public int CalculatedStatementBody
{
get
{
return 1;
}
}
public Foo ThisExpressionBody => this;
public int CalculatedReturningFieldExpressionBody => this.value;
public int CalculatedReturningFieldStatementBody
{
get
{
return this.value;
}
}
}
}".AssertReplace("var temp = CalculatedExpressionBody", $"var temp = {code}");
var syntaxTree = CSharpSyntaxTree.ParseText(testCode);
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.FindEqualsValueClause(code).Value;
using (var returnValues = ReturnValueWalker.Borrow(value, search, semanticModel, CancellationToken.None))
{
var actual = string.Join(", ", returnValues);
Assert.AreEqual(expected, actual);
}
}
public static void PropertyRecursive(string expression, ReturnValueSearch search, string expected)
{
var code = @"
namespace N
{
internal class C
{
internal C()
{
var temp = StaticRecursiveExpressionBody;
}
public static int StaticRecursiveExpressionBody => StaticRecursiveExpressionBody;
public static int StaticRecursiveStatementBody
{
get
{
return StaticRecursiveStatementBody;
}
}
public int RecursiveExpressionBody => this.RecursiveExpressionBody;
public int RecursiveStatementBody
{
get
{
return this.RecursiveStatementBody;
}
}
}
}".AssertReplace("var temp = StaticRecursiveExpressionBody", $"var temp = {expression}");
var syntaxTree = CSharpSyntaxTree.ParseText(code);
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.FindEqualsValueClause(expression).Value;
using var returnValues = ReturnValueWalker.Borrow(value, search, semanticModel, CancellationToken.None);
var actual = string.Join(", ", returnValues);
Assert.AreEqual(expected, actual);
}
public static bool IsEither(this ReturnValueSearch search, ReturnValueSearch search1, ReturnValueSearch search2) => search == search1 || search == search2;
public static void AsyncAwait(string expression, ReturnValueSearch search, string expected)
{
var code = @"
namespace N
{
using System;
using System.Threading.Tasks;
public class Disposable : IDisposable
{
public void Dispose()
{
}
}
internal class C
{
internal async Task M()
{
var value = await CreateStringAsync();
}
internal static int CreateInt() => 1;
internal static async Task<string> CreateStringAsync()
{
await Task.Delay(0);
return new string(' ', 1);
}
internal static async Task<int> CreateIntAsync()
{
await Task.Delay(0);
return 1;
}
internal static Task<int> ReturnTaskFromResultAsync() => Task.FromResult(1);
internal static Task<int> ReturnTaskFromResultAsync(int arg) => Task.FromResult(arg);
internal static async Task<string> ReturnAwaitTaskRunAsync() => await Task.Run(() => new string(' ', 1));
internal static async Task<string> ReturnAwaitTaskRunConfigureAwaitAsync() => await Task.Run(() => new string(' ', 1)).ConfigureAwait(false);
internal static Task<int> CreateAsync(int arg)
{
switch (arg)
{
case 0:
return Task.FromResult(1);
case 1:
return Task.FromResult(arg);
case 2:
return Task.Run(() => 2);
case 3:
return Task.Run(() => arg);
case 4:
return Task.Run(() => { return 3; });
default:
return Task.Run(() => { return arg; });
}
}
}
}".AssertReplace("var value = await CreateStringAsync()", $"var value = {expression}");
var syntaxTree = CSharpSyntaxTree.ParseText(code);
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.FindEqualsValueClause(expression).Value;
using var returnValues = ReturnValueWalker.Borrow(value, search, semanticModel, CancellationToken.None);
Assert.AreEqual(expected, string.Join(", ", returnValues));
}
public static void CallRecursive(string expression, ReturnValueSearch search, string expected)
{
var code = @"
namespace N
{
using System;
using System.Collections.Generic;
using System.IO;
internal class C
{
internal C()
{
var temp = Recursive();
}
public static int Recursive() => Recursive();
public static int Recursive(int arg) => Recursive(arg);
public static bool Recursive(bool flag)
{
if (flag)
{
return Recursive(!flag);
}
return flag;
}
private static int RecursiveWithOptional(int arg, IEnumerable<int> args = null)
{
if (arg == null)
{
return RecursiveWithOptional(arg, new[] { arg });
}
return arg;
}
private static int Recursive1(int value)
{
return Recursive2(value);
}
private static int Recursive2(int value)
{
return Recursive1(value);
}
private static IReadOnlyList<IDisposable> Flatten(IReadOnlyList<IDisposable> source, List<IDisposable> result = null)
{
result = result ?? new List<IDisposable>();
result.AddRange(source);
foreach (var condition in source)
{
Flatten(new[] { condition }, result);
}
return result;
}
}
}".AssertReplace("var temp = Recursive()", $"var temp = {expression}");
var syntaxTree = CSharpSyntaxTree.ParseText(code);
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.FindEqualsValueClause(expression).Value;
using var returnValues = ReturnValueWalker.Borrow(value, search, semanticModel, CancellationToken.None);
var actual = string.Join(", ", returnValues);
Assert.AreEqual(expected, actual);
}
public static void Call(string expression, ReturnValueSearch search, string expected)
{
var code = @"
namespace N
{
using System;
using System.Collections.Generic;
using System.IO;
internal class C
{
internal C()
{
var temp = StaticCreateIntStatementBody();
}
internal static int StaticCreateIntStatementBody()
{
return 1;
}
internal static int StaticCreateIntExpressionBody() => 2;
internal static int IdStatementBody(int arg)
{
return arg;
}
internal static int IdExpressionBody(int arg) => arg;
internal static int OptionalIdExpressionBody(int arg = 1) => arg;
internal static int CallingIdExpressionBody(int arg1) => IdExpressionBody(arg1);
public static int AssigningToParameter(int arg)
{
if (true)
{
return arg;
}
else
{
if (true)
{
arg = 2;
}
else
{
arg = 3;
}
return arg;
}
return 4;
}
public static int ConditionalId(int arg)
{
if (true)
{
return arg;
}
return arg;
}
public static int ReturnLocal()
{
var local = 1;
return local;
}
public static int ReturnLocalAssignedTwice(bool flag)
{
var local = 1;
local = 2;
if (flag)
{
return local;
}
local = 5;
return 3;
}
public C ThisExpressionBody() => this;
public static Stream ReturningFileOpenRead()
{
return System.IO.File.OpenRead(string.Empty);
}
public static Stream ReturningLocalFileOpenRead()
{
var stream = System.IO.File.OpenRead(string.Empty);
return stream;
}
}
}".AssertReplace("var temp = StaticCreateIntStatementBody()", $"var temp = {expression}");
var syntaxTree = CSharpSyntaxTree.ParseText(code);
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.FromAttributes());
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.FindEqualsValueClause(expression).Value;
using var returnValues = ReturnValueWalker.Borrow(value, search, semanticModel, CancellationToken.None);
var actual = string.Join(", ", returnValues);
Assert.AreEqual(expected, actual);
}