internal static async Task TestAddConstructorAsync(
string initial,
string expected,
string name = "C",
Accessibility accessibility = Accessibility.Public,
Editing.DeclarationModifiers modifiers = default(Editing.DeclarationModifiers),
ImmutableArray <Func <SemanticModel, IParameterSymbol> > parameters = default(ImmutableArray <Func <SemanticModel, IParameterSymbol> >),
ImmutableArray <SyntaxNode> statements = default(ImmutableArray <SyntaxNode>),
ImmutableArray <SyntaxNode> baseArguments = default(ImmutableArray <SyntaxNode>),
ImmutableArray <SyntaxNode> thisArguments = default(ImmutableArray <SyntaxNode>),
CodeGenerationOptions codeGenerationOptions = default(CodeGenerationOptions),
bool ignoreTrivia = true)
{
using (var context = await TestContext.CreateAsync(initial, expected, ignoreTrivia))
{
var parameterSymbols = GetParameterSymbols(parameters, context);
var ctor = CodeGenerationSymbolFactory.CreateConstructorSymbol(
default(ImmutableArray <AttributeData>),
accessibility,
modifiers,
name,
parameterSymbols,
statements,
baseConstructorArguments: baseArguments,
thisConstructorArguments: thisArguments);
context.Result = await context.Service.AddMethodAsync(context.Solution, (INamedTypeSymbol)context.GetDestination(), ctor, codeGenerationOptions);
}
}
internal static async Task TestAddEventAsync(
string initial,
string expected,
string name = "E",
ImmutableArray <AttributeData> attributes = default(ImmutableArray <AttributeData>),
Accessibility accessibility = Accessibility.Public,
Editing.DeclarationModifiers modifiers = default(Editing.DeclarationModifiers),
ImmutableArray <Func <SemanticModel, IParameterSymbol> > parameters = default(ImmutableArray <Func <SemanticModel, IParameterSymbol> >),
Type type = null,
Func <SemanticModel, ImmutableArray <IEventSymbol> > getExplicitInterfaceImplementations = null,
IMethodSymbol addMethod = null,
IMethodSymbol removeMethod = null,
IMethodSymbol raiseMethod = null,
CodeGenerationOptions codeGenerationOptions = default(CodeGenerationOptions),
bool ignoreTrivia = true)
{
using (var context = await TestContext.CreateAsync(initial, expected, ignoreTrivia))
{
type = type ?? typeof(Action);
var parameterSymbols = GetParameterSymbols(parameters, context);
var typeSymbol = GetTypeSymbol(type)(context.SemanticModel);
var @event = CodeGenerationSymbolFactory.CreateEventSymbol(
attributes,
accessibility,
modifiers,
typeSymbol,
getExplicitInterfaceImplementations?.Invoke(context.SemanticModel) ?? default,
name,
addMethod,
removeMethod,
raiseMethod);
context.Result = await context.Service.AddEventAsync(context.Solution, (INamedTypeSymbol)context.GetDestination(), @event, codeGenerationOptions);
}
}
internal static async Task TestAddConversionAsync(
string initial,
string expected,
Type toType,
Func <SemanticModel, IParameterSymbol> fromType,
bool isImplicit = false,
Accessibility accessibility = Accessibility.Public,
Editing.DeclarationModifiers modifiers = default(Editing.DeclarationModifiers),
string statements = null,
CodeGenerationOptions codeGenerationOptions = default(CodeGenerationOptions),
bool ignoreTrivia = true)
{
if (statements != null)
{
expected = expected.Replace("$$", statements);
}
using (var context = await TestContext.CreateAsync(initial, expected, ignoreTrivia))
{
var parsedStatements = context.ParseStatements(statements);
var method = CodeGenerationSymbolFactory.CreateConversionSymbol(
default(ImmutableArray <AttributeData>),
accessibility,
modifiers,
GetTypeSymbol(toType)(context.SemanticModel),
fromType(context.SemanticModel),
isImplicit,
parsedStatements);
context.Result = await context.Service.AddMethodAsync(context.Solution, (INamedTypeSymbol)context.GetDestination(), method, codeGenerationOptions);
}
}
internal static async Task TestAddDelegateTypeAsync(
string initial,
string expected,
string name = "D",
Accessibility accessibility = Accessibility.Public,
Editing.DeclarationModifiers modifiers = default(Editing.DeclarationModifiers),
Type returnType = null,
ImmutableArray <ITypeParameterSymbol> typeParameters = default(ImmutableArray <ITypeParameterSymbol>),
ImmutableArray <Func <SemanticModel, IParameterSymbol> > parameters = default(ImmutableArray <Func <SemanticModel, IParameterSymbol> >),
CodeGenerationOptions codeGenerationOptions = default(CodeGenerationOptions),
bool ignoreTrivia = true)
{
using (var context = await TestContext.CreateAsync(initial, expected, ignoreTrivia))
{
var parameterSymbols = GetParameterSymbols(parameters, context);
var type = CodeGenerationSymbolFactory.CreateDelegateTypeSymbol(
default(ImmutableArray <AttributeData>),
accessibility,
modifiers,
GetTypeSymbol(returnType)(context.SemanticModel),
false,
name,
typeParameters,
parameterSymbols);
context.Result = await context.Service.AddNamedTypeAsync(context.Solution, (INamedTypeSymbol)context.GetDestination(), type, codeGenerationOptions);
}
}
internal static async Task TestAddFieldAsync(
string initial,
string expected,
Func<SemanticModel, ITypeSymbol> type = null,
string name = "F",
Accessibility accessibility = Accessibility.Public,
Editing.DeclarationModifiers modifiers = default(Editing.DeclarationModifiers),
CodeGenerationOptions codeGenerationOptions = null,
bool hasConstantValue = false,
object constantValue = null,
bool addToCompilationUnit = false)
{
using (var context = await TestContext.CreateAsync(initial, expected))
{
var typeSymbol = type != null ? type(context.SemanticModel) : null;
var field = CodeGenerationSymbolFactory.CreateFieldSymbol(
default(ImmutableArray<AttributeData>),
accessibility,
modifiers,
typeSymbol,
name,
hasConstantValue,
constantValue);
if (!addToCompilationUnit)
{
context.Result = await context.Service.AddFieldAsync(context.Solution, (INamedTypeSymbol)context.GetDestination(), field, codeGenerationOptions);
}
else
{
var newRoot = context.Service.AddField(await context.Document.GetSyntaxRootAsync(), field, codeGenerationOptions);
context.Result = context.Document.WithSyntaxRoot(newRoot);
}
}
}
internal static async Task TestAddPropertyAsync(
string initial,
string expected,
string name = "P",
Accessibility defaultAccessibility = Accessibility.Public,
Accessibility setterAccessibility = Accessibility.Public,
Editing.DeclarationModifiers modifiers = default(Editing.DeclarationModifiers),
string getStatements = null,
string setStatements = null,
Type type = null,
ImmutableArray <IPropertySymbol> explicitInterfaceImplementations = default,
ImmutableArray <Func <SemanticModel, IParameterSymbol> > parameters = default(ImmutableArray <Func <SemanticModel, IParameterSymbol> >),
bool isIndexer = false,
CodeGenerationOptions codeGenerationOptions = default(CodeGenerationOptions),
bool ignoreTrivia = true,
IDictionary <OptionKey, object> options = null)
{
// This assumes that tests will not use place holders for get/set statements at the same time
if (getStatements != null)
{
expected = expected.Replace("$$", getStatements);
}
if (setStatements != null)
{
expected = expected.Replace("$$", setStatements);
}
using (var context = await TestContext.CreateAsync(initial, expected, ignoreTrivia))
{
if (options != null)
{
foreach (var kvp in options)
{
context.Workspace.Options = context.Workspace.Options.WithChangedOption(kvp.Key, kvp.Value);
}
}
var typeSymbol = GetTypeSymbol(type)(context.SemanticModel);
var getParameterSymbols = GetParameterSymbols(parameters, context);
var setParameterSymbols = getParameterSymbols == null
? default(ImmutableArray <IParameterSymbol>)
: getParameterSymbols.Add(Parameter(type, "value")(context.SemanticModel));
IMethodSymbol getAccessor = CodeGenerationSymbolFactory.CreateMethodSymbol(
default(ImmutableArray <AttributeData>),
defaultAccessibility,
new Editing.DeclarationModifiers(isAbstract: getStatements == null),
typeSymbol,
false,
internal static async Task TestAddFieldAsync(
string initial,
string expected,
Func<SemanticModel, ITypeSymbol> type = null,
string name = "F",
Accessibility accessibility = Accessibility.Public,
Editing.DeclarationModifiers modifiers = default,
CodeGenerationOptions codeGenerationOptions = null,
bool hasConstantValue = false,
object constantValue = null,
bool addToCompilationUnit = false)
{
using var context = await TestContext.CreateAsync(initial, expected);
var typeSymbol = type != null ? type(context.SemanticModel) : null;
var field = CodeGenerationSymbolFactory.CreateFieldSymbol(
attributes: default,
internal static async Task TestAddUnsupportedOperatorAsync(
string initial,
CodeGenerationOperatorKind operatorKind,
Accessibility accessibility = Accessibility.Public,
Editing.DeclarationModifiers modifiers = default(Editing.DeclarationModifiers),
Type returnType = null,
ImmutableArray <Func <SemanticModel, IParameterSymbol> > parameters = default(ImmutableArray <Func <SemanticModel, IParameterSymbol> >),
string statements = null,
CodeGenerationOptions codeGenerationOptions = default(CodeGenerationOptions),
bool ignoreTrivia = true)
{
using (var context = await TestContext.CreateAsync(initial, initial, ignoreResult: true))
{
var parameterSymbols = GetParameterSymbols(parameters, context);
var parsedStatements = context.ParseStatements(statements);
var method = CodeGenerationSymbolFactory.CreateOperatorSymbol(
default(ImmutableArray <AttributeData>),
accessibility,
modifiers,
GetTypeSymbol(returnType)(context.SemanticModel),
operatorKind,
parameterSymbols,
parsedStatements);
ArgumentException exception = null;
try
{
await context.Service.AddMethodAsync(context.Solution, (INamedTypeSymbol)context.GetDestination(), method, codeGenerationOptions);
}
catch (ArgumentException e)
{
exception = e;
}
var expectedMessage = string.Format(WorkspacesResources.Cannot_generate_code_for_unsupported_operator_0, method.Name);
Assert.True(exception != null && exception.Message.StartsWith(expectedMessage, StringComparison.Ordinal),
string.Format("\r\nExpected exception: {0}\r\nActual exception: {1}\r\n", expectedMessage, exception == null ? "no exception" : exception.Message));
}
}
internal static async Task TestAddMethodAsync(
string initial,
string expected,
string name = "M",
Accessibility accessibility = Accessibility.Public,
Editing.DeclarationModifiers modifiers = default(Editing.DeclarationModifiers),
Type returnType = null,
Func <SemanticModel, ImmutableArray <IMethodSymbol> > getExplicitInterfaces = null,
ImmutableArray <ITypeParameterSymbol> typeParameters = default(ImmutableArray <ITypeParameterSymbol>),
ImmutableArray <Func <SemanticModel, IParameterSymbol> > parameters = default(ImmutableArray <Func <SemanticModel, IParameterSymbol> >),
string statements = null,
ImmutableArray <SyntaxNode> handlesExpressions = default(ImmutableArray <SyntaxNode>),
CodeGenerationOptions codeGenerationOptions = default(CodeGenerationOptions),
bool ignoreTrivia = true)
{
if (statements != null)
{
expected = expected.Replace("$$", statements);
}
using (var context = await TestContext.CreateAsync(initial, expected, ignoreTrivia))
{
var parameterSymbols = GetParameterSymbols(parameters, context);
var parsedStatements = context.ParseStatements(statements);
var explicitInterfaceImplementations = GetMethodSymbols(getExplicitInterfaces, context);
var method = CodeGenerationSymbolFactory.CreateMethodSymbol(
default(ImmutableArray <AttributeData>),
accessibility,
modifiers,
GetTypeSymbol(returnType)(context.SemanticModel),
false,
explicitInterfaceImplementations,
name,
typeParameters,
parameterSymbols,
parsedStatements,
handlesExpressions: handlesExpressions);
context.Result = await context.Service.AddMethodAsync(context.Solution, (INamedTypeSymbol)context.GetDestination(), method, codeGenerationOptions);
}
}
internal static async Task TestAddOperatorsAsync(
string initial,
string expected,
CodeGenerationOperatorKind[] operatorKinds,
Accessibility accessibility = Accessibility.Public,
Editing.DeclarationModifiers modifiers = default(Editing.DeclarationModifiers),
Type returnType = null,
ImmutableArray <Func <SemanticModel, IParameterSymbol> > parameters = default(ImmutableArray <Func <SemanticModel, IParameterSymbol> >),
string statements = null,
CodeGenerationOptions codeGenerationOptions = default(CodeGenerationOptions),
bool ignoreTrivia = true)
{
if (statements != null)
{
while (expected.IndexOf("$$", StringComparison.Ordinal) != -1)
{
expected = expected.Replace("$$", statements);
}
}
using (var context = await TestContext.CreateAsync(initial, expected, ignoreTrivia))
{
var parameterSymbols = GetParameterSymbols(parameters, context);
var parsedStatements = context.ParseStatements(statements);
var methods = operatorKinds.Select(kind => CodeGenerationSymbolFactory.CreateOperatorSymbol(
default(ImmutableArray <AttributeData>),
accessibility,
modifiers,
GetTypeSymbol(returnType)(context.SemanticModel),
kind,
parameterSymbols,
parsedStatements));
context.Result = await context.Service.AddMembersAsync(context.Solution, (INamedTypeSymbol)context.GetDestination(), methods.ToArray(), codeGenerationOptions);
}
}
