public void Lambda(string code, Search search, string expected)
{
var testCode = @"
namespace RoslynSandbox
{
using System;
internal class Foo
{
internal Foo()
{
Func<int> temp = () => 1;
}
internal static int StaticCreateIntStatementBody()
{
return 1;
}
}
}";
testCode = testCode.AssertReplace("Func<int> temp = () => 1", code);
var syntaxTree = CSharpSyntaxTree.ParseText(testCode);
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.All);
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.BestMatch <EqualsValueClauseSyntax>(code).Value;
using (var pooled = ReturnValueWalker.Create(value, search, semanticModel, CancellationToken.None))
{
var actual = string.Join(", ", pooled.Item);
Assert.AreEqual(expected, actual);
}
}
public void AwaitSyntaxError(Search search, string expected)
{
var testCode = @"
using System.Threading.Tasks;
internal class Foo
{
internal static async Task Bar()
{
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(testCode);
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.All);
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.BestMatch <EqualsValueClauseSyntax>("var text = await CreateAsync()").Value;
using (var pooled = ReturnValueWalker.Create(value, search, semanticModel, CancellationToken.None))
{
var actual = string.Join(", ", pooled.Item);
Assert.AreEqual(expected, actual);
}
}
public void Property(string code, Search search, string expected)
{
var testCode = @"
namespace RoslynSandbox
{
internal class Foo
{
private readonly int value = 1;
internal Foo()
{
var temp = // Meh();
}
public static int StaticRecursiveExpressionBody => StaticRecursiveExpressionBody;
public static int StaticRecursiveStatementBody
{
get
{
return StaticRecursiveStatementBody;
}
}
public int RecursiveExpressionBody => this.RecursiveExpressionBody;
public int RecursiveStatementBody
{
get
{
return this.RecursiveStatementBody;
}
}
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;
}
}
}
}";
testCode = testCode.AssertReplace("// Meh()", code);
var syntaxTree = CSharpSyntaxTree.ParseText(testCode);
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.All);
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.BestMatch <EqualsValueClauseSyntax>(code).Value;
using (var pooled = ReturnValueWalker.Create(value, search, semanticModel, CancellationToken.None))
{
var actual = string.Join(", ", pooled.Item);
Assert.AreEqual(expected, actual);
}
}
public void AsyncAwait(string code, Search 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 = // Meh();
}
internal static async Task<int> RecursiveAsync() => RecursiveAsync();
internal static async Task<int> RecursiveAsync(int arg) => RecursiveAsync(arg);
internal static async Task<string> CreateStringAsync()
{
await Task.Delay(0);
return new string(' ', 1);
}
internal static async Task<string> ReturnAwaitTaskRunAsync()
{
await Task.Delay(0);
return 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; });
}
}
internal static async int CreateInt() => 1;
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 async Task<int> RecursiveAsync3(int value)
{
return RecursiveAsync4(value);
}
private static async Task<int> RecursiveAsync4(int value)
{
return await RecursiveAsync3(value);
}
}
}";
testCode = testCode.AssertReplace("// Meh()", code);
var syntaxTree = CSharpSyntaxTree.ParseText(testCode);
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.All);
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.BestMatch <EqualsValueClauseSyntax>(code).Value;
using (var pooled = ReturnValueWalker.Create(value, search, semanticModel, CancellationToken.None))
{
Assert.AreEqual(expected, string.Join(", ", pooled.Item));
}
}
public void Call(string code, Search search, string expected)
{
var testCode = @"
namespace RoslynSandbox
{
using System;
using System.Collections.Generic;
internal class Foo
{
internal Foo()
{
var temp = // Meh();
}
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 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;
}
public Foo ThisExpressionBody() => this;
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);
}
}
}";
testCode = testCode.AssertReplace("// Meh()", code);
var syntaxTree = CSharpSyntaxTree.ParseText(testCode);
var compilation = CSharpCompilation.Create("test", new[] { syntaxTree }, MetadataReferences.All);
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var value = syntaxTree.BestMatch <EqualsValueClauseSyntax>(code).Value;
using (var pooled = ReturnValueWalker.Create(value, search, semanticModel, CancellationToken.None))
{
var actual = string.Join(", ", pooled.Item);
Assert.AreEqual(expected, actual);
}
}