protected override OperationStatus <IMethodSymbol> GenerateMethodDefinition(CancellationToken cancellationToken)
{
var result = CreateMethodBody(cancellationToken);
var methodSymbol = CodeGenerationSymbolFactory.CreateMethodSymbol(
attributes: SpecializedCollections.EmptyList <AttributeData>(),
accessibility: Accessibility.Private,
modifiers: CreateMethodModifiers(),
returnType: this.AnalyzerResult.ReturnType,
explicitInterfaceSymbol: null,
name: _methodName.ToString(),
typeParameters: CreateMethodTypeParameters(cancellationToken),
parameters: CreateMethodParameters(),
statements: result.Data);
return(result.With(
this.MethodDefinitionAnnotation.AddAnnotationToSymbol(
Formatter.Annotation.AddAnnotationToSymbol(methodSymbol))));
}
public void TestThrowsOnGenerateNamespace()
{
var namespaceSymbol = CodeGenerationSymbolFactory.CreateNamespaceSymbol("Outerspace");
using (var context = new TestContext())
{
Assert.Throws <ArgumentException>(() =>
{
try
{
context.GenerateSource(namespaceSymbol);
}
catch (AggregateException ae)
{
throw ae.InnerException;
}
});
}
}
private static IMethodSymbol GenerateMethodSymbol(INamedTypeSymbol typeToGenerateIn, INamedTypeSymbol parameterSymbol)
{
// Remove any generic parameters
if (typeToGenerateIn.IsGenericType)
{
typeToGenerateIn = typeToGenerateIn.ConstructUnboundGenericType().ConstructedFrom;
}
return(CodeGenerationSymbolFactory.CreateMethodSymbol(
attributes: SpecializedCollections.EmptyList <AttributeData>(),
accessibility: default(Accessibility),
modifiers: default(DeclarationModifiers),
returnType: typeToGenerateIn,
explicitInterfaceSymbol: null,
name: null,
typeParameters: SpecializedCollections.EmptyList <ITypeParameterSymbol>(),
parameters: new[] { CodeGenerationSymbolFactory.CreateParameterSymbol(parameterSymbol, "v") },
methodKind: MethodKind.Conversion));
}
private static async Task <ISymbol?> TryRehydrateAsync(
Document document,
CompletionItem item,
CancellationToken cancellationToken
)
{
// If we're need to rehydrate the conversion, pull out the necessary parts.
if (item.Properties.ContainsKey(RehydrateName))
{
var symbols = await SymbolCompletionItem
.GetSymbolsAsync(item, document, cancellationToken)
.ConfigureAwait(false);
if (
symbols.Length == 3 &&
symbols[0] is INamedTypeSymbol containingType &&
symbols[1] is ITypeSymbol fromType &&
symbols[2] is ITypeSymbol toType
)
{
return(CodeGenerationSymbolFactory.CreateConversionSymbol(
toType: toType,
fromType: CodeGenerationSymbolFactory.CreateParameterSymbol(
fromType,
"value"
),
containingType: containingType,
documentationCommentXml: item.Properties[DocumentationCommentXmlName]
));
}
return(null);
}
else
{
// Otherwise, just go retrieve the conversion directly.
var symbols = await SymbolCompletionItem
.GetSymbolsAsync(item, document, cancellationToken)
.ConfigureAwait(false);
return(symbols.Length == 1 ? symbols.Single() : null);
}
}
private IPropertySymbol GenerateProperty(
IPropertySymbol property,
DeclarationModifiers modifiers,
Accessibility accessibility,
ImplementTypePropertyGenerationBehavior propertyGenerationBehavior,
CancellationToken cancellationToken)
{
if (property.GetMethod == null)
{
// Can't generate an auto-prop for a setter-only property.
propertyGenerationBehavior = ImplementTypePropertyGenerationBehavior.PreferThrowingProperties;
}
var syntaxFactory = _document.GetLanguageService <SyntaxGenerator>();
var accessorBody = propertyGenerationBehavior == ImplementTypePropertyGenerationBehavior.PreferAutoProperties
? default
: syntaxFactory.CreateThrowNotImplementedStatementBlock(_model.Compilation);
var getMethod = ShouldGenerateAccessor(property.GetMethod)
? CodeGenerationSymbolFactory.CreateAccessorSymbol(
property.GetMethod,
attributes: default,
accessibility: property.GetMethod.ComputeResultantAccessibility(_state.ClassType),
statements: accessorBody)
: null;
var setMethod = ShouldGenerateAccessor(property.SetMethod)
? CodeGenerationSymbolFactory.CreateAccessorSymbol(
property.SetMethod,
attributes: default,
accessibility: property.SetMethod.ComputeResultantAccessibility(_state.ClassType),
statements: accessorBody)
: null;
return(CodeGenerationSymbolFactory.CreatePropertySymbol(
property,
accessibility: accessibility,
modifiers: modifiers,
getMethod: getMethod,
setMethod: setMethod));
}
internal static IMethodSymbol GenerateSetPropertyMethod(Compilation compilation)
{
var body = SyntaxFactory.ParseStatement(
@"if (!System.Collections.Generic.EqualityComparer<T>.Default.Equals(field, value))
{
field = value;
var handler = PropertyChanged;
if (handler != null)
{
handler(this, new System.ComponentModel.PropertyChangedEventArgs(name));
}
}");
body = body.WithAdditionalAnnotations(Simplifier.Annotation);
var stringType = compilation.GetSpecialType(SpecialType.System_String);
var voidType = compilation.GetSpecialType(SpecialType.System_Void);
var typeParameter = CodeGenerationSymbolFactory.CreateTypeParameterSymbol("T");
var parameter1 = CodeGenerationSymbolFactory.CreateParameterSymbol(
attributes: null,
refKind: RefKind.Ref,
isParams: false,
type: typeParameter,
name: "field");
var parameter2 = CodeGenerationSymbolFactory.CreateParameterSymbol(typeParameter, "value");
var parameter3 = CodeGenerationSymbolFactory.CreateParameterSymbol(stringType, "name");
return(CodeGenerationSymbolFactory.CreateMethodSymbol(
attributes: null,
accessibility: Microsoft.CodeAnalysis.Accessibility.Private,
modifiers: new SymbolModifiers(),
returnType: voidType,
explicitInterfaceSymbol: null,
name: "SetProperty",
typeParameters: new[] { typeParameter },
parameters: new[] { parameter1, parameter2, parameter3 },
statements: new[] { body }));
}
private static SyntaxNode GetNewMethodDeclaration(
IMethodSymbol method,
TArgumentSyntax argument,
SeparatedSyntaxList <TArgumentSyntax> argumentList,
SyntaxGenerator generator,
SyntaxNode declaration,
ISemanticFactsService semanticFacts,
string argumentName,
SyntaxNode expression,
SemanticModel semanticModel,
ITypeSymbol parameterType)
{
if (!string.IsNullOrWhiteSpace(argumentName))
{
var newParameterSymbol = CodeGenerationSymbolFactory.CreateParameterSymbol(
attributes: default(ImmutableArray <AttributeData>),
refKind: RefKind.None,
isParams: false,
type: parameterType,
name: argumentName);
var newParameterDeclaration = generator.ParameterDeclaration(newParameterSymbol);
return(generator.AddParameters(declaration, new[] { newParameterDeclaration }));
}
else
{
var name = semanticFacts.GenerateNameForExpression(semanticModel, expression);
var uniqueName = NameGenerator.EnsureUniqueness(name, method.Parameters.Select(p => p.Name));
var newParameterSymbol = CodeGenerationSymbolFactory.CreateParameterSymbol(
attributes: default(ImmutableArray <AttributeData>),
refKind: RefKind.None,
isParams: false,
type: parameterType,
name: uniqueName);
var argumentIndex = argumentList.IndexOf(argument);
var newParameterDeclaration = generator.ParameterDeclaration(newParameterSymbol);
return(generator.InsertParameters(
declaration, argumentIndex, new[] { newParameterDeclaration }));
}
}
internal IPropertySymbol GenerateProperty(
SyntaxGenerator factory,
bool isAbstract, bool includeSetter,
CancellationToken cancellationToken)
{
var accessibility = DetermineAccessibility(isAbstract);
var getMethod = CodeGenerationSymbolFactory.CreateAccessorSymbol(
attributes: default(ImmutableArray <AttributeData>),
accessibility: accessibility,
statements: GenerateStatements(factory, isAbstract, cancellationToken));
var setMethod = includeSetter ? getMethod : null;
return(CodeGenerationSymbolFactory.CreatePropertySymbol(
attributes: default(ImmutableArray <AttributeData>),
accessibility: accessibility,
modifiers: new DeclarationModifiers(isStatic: State.IsStatic, isAbstract: isAbstract),
type: DetermineReturnType(cancellationToken),
returnsByRef: DetermineReturnsByRef(cancellationToken),
explicitInterfaceImplementations: default,
private IEnumerable <CodeAction> CreateCodeActions(Document document, State state)
{
var lastParameter = state.DelegatedConstructor.Parameters.Last();
if (!lastParameter.IsOptional)
{
yield return(new AddConstructorParametersCodeAction(this, document, state, state.Parameters));
}
var parameters = state.Parameters.Select(p => CodeGenerationSymbolFactory.CreateParameterSymbol(
attributes: null,
refKind: p.RefKind,
isParams: p.IsParams,
type: p.Type,
name: p.Name,
isOptional: true,
hasDefaultValue: true)).ToList();
yield return(new AddConstructorParametersCodeAction(this, document, state, parameters));
}
protected IList <IParameterSymbol> CreateMethodParameters()
{
var parameters = new List <IParameterSymbol>();
foreach (var parameter in this.AnalyzerResult.MethodParameters)
{
var refKind = GetRefKind(parameter.ParameterModifier);
var type = parameter.GetVariableType(this.SemanticDocument);
parameters.Add(
CodeGenerationSymbolFactory.CreateParameterSymbol(
attributes: SpecializedCollections.EmptyList <AttributeData>(),
refKind: refKind,
isParams: false,
type: type,
name: parameter.Name));
}
return(parameters);
}
private void AddExceptionConstructors(ArrayBuilder <ISymbol> members)
{
var factory = _document.Project.LanguageServices.GetService <SyntaxGenerator>();
var exceptionType = _document.SemanticModel.Compilation.ExceptionType();
var constructors =
exceptionType.InstanceConstructors
.Where(c => c.DeclaredAccessibility == Accessibility.Public || c.DeclaredAccessibility == Accessibility.Protected)
.Select(c => CodeGenerationSymbolFactory.CreateConstructorSymbol(
attributes: default(ImmutableArray <AttributeData>),
accessibility: c.DeclaredAccessibility,
modifiers: default(DeclarationModifiers),
typeName: DetermineName(),
parameters: c.Parameters,
statements: default(ImmutableArray <SyntaxNode>),
baseConstructorArguments: c.Parameters.Length == 0
? default(ImmutableArray <SyntaxNode>)
: factory.CreateArguments(c.Parameters)));
members.AddRange(constructors);
}
protected ImmutableArray <IParameterSymbol> CreateMethodParameters()
{
var parameters = ArrayBuilder <IParameterSymbol> .GetInstance();
foreach (var parameter in AnalyzerResult.MethodParameters)
{
var refKind = GetRefKind(parameter.ParameterModifier);
var type = parameter.GetVariableType(SemanticDocument);
parameters.Add(
CodeGenerationSymbolFactory.CreateParameterSymbol(
attributes: ImmutableArray <AttributeData> .Empty,
refKind: refKind,
isParams: false,
type: type,
name: parameter.Name));
}
return(parameters.ToImmutableAndFree());
}
protected override async Task <OperationStatus <IMethodSymbol> > GenerateMethodDefinitionAsync(CancellationToken cancellationToken)
{
var result = await CreateMethodBodyAsync(cancellationToken).ConfigureAwait(false);
var methodSymbol = CodeGenerationSymbolFactory.CreateMethodSymbol(
attributes: ImmutableArray <AttributeData> .Empty,
accessibility: Accessibility.Private,
modifiers: CreateMethodModifiers(),
returnType: this.AnalyzerResult.ReturnType,
returnsByRef: false,
explicitInterfaceSymbol: null,
name: _methodName.ToString(),
typeParameters: CreateMethodTypeParameters(cancellationToken),
parameters: CreateMethodParameters(),
statements: result.Data);
return(result.With(
this.MethodDefinitionAnnotation.AddAnnotationToSymbol(
Formatter.Annotation.AddAnnotationToSymbol(methodSymbol))));
}
public static IMethodSymbol CreateEqualsMethod(
this ISyntaxFactoryService factory,
Compilation compilation,
INamedTypeSymbol containingType,
IList <ISymbol> symbols,
CancellationToken cancellationToken)
{
var statements = CreateEqualsMethodStatements(factory, compilation, containingType, symbols, cancellationToken);
return(CodeGenerationSymbolFactory.CreateMethodSymbol(
attributes: null,
accessibility: Accessibility.Public,
modifiers: new SymbolModifiers(isOverride: true),
returnType: compilation.GetSpecialType(SpecialType.System_Boolean),
explicitInterfaceSymbol: null,
name: EqualsName,
typeParameters: null,
parameters: new[] { CodeGenerationSymbolFactory.CreateParameterSymbol(compilation.GetSpecialType(SpecialType.System_Object), ObjName) },
statements: statements));
}
public static IMethodSymbol CreateGetHashCodeMethod(
this SyntaxGenerator factory,
Compilation compilation,
INamedTypeSymbol containingType,
IList <ISymbol> symbols,
CancellationToken cancellationToken)
{
var statements = CreateGetHashCodeMethodStatements(factory, compilation, containingType, symbols, cancellationToken);
return(CodeGenerationSymbolFactory.CreateMethodSymbol(
attributes: null,
accessibility: Accessibility.Public,
modifiers: new DeclarationModifiers(isOverride: true),
returnType: compilation.GetSpecialType(SpecialType.System_Int32),
explicitInterfaceSymbol: null,
name: GetHashCodeName,
typeParameters: null,
parameters: null,
statements: statements));
}
internal async override Task <Document> GetUpdatedDocumentAsync(Document document, SemanticModel model, SyntaxNode root, SyntaxNode nodeToFix, string diagnosticId, CancellationToken cancellationToken)
{
var syntaxFactoryService = document.GetLanguageService <SyntaxGenerator>();
var symbol = model.GetDeclaredSymbol(nodeToFix);
// There was no constructor and so the diagnostic was on the type. Generate a serlialization ctor.
if (symbol.Kind == SymbolKind.NamedType)
{
var typeSymbol = symbol as INamedTypeSymbol;
var throwStatement = syntaxFactoryService.CreateThrowNotImplementedStatementBlock(model.Compilation);
var parameters = ImmutableArray.Create(
CodeGenerationSymbolFactory.CreateParameterSymbol(WellKnownTypes.SerializationInfo(model.Compilation), "serializationInfo"),
CodeGenerationSymbolFactory.CreateParameterSymbol(WellKnownTypes.StreamingContext(model.Compilation), "streamingContext"));
var ctorSymbol = CodeGenerationSymbolFactory.CreateConstructorSymbol(null,
typeSymbol.IsSealed ? Accessibility.Private : Accessibility.Protected,
new SymbolModifiers(),
typeSymbol.Name,
parameters,
throwStatement);
return(await CodeGenerator.AddMethodDeclarationAsync(document.Project.Solution, typeSymbol, ctorSymbol).ConfigureAwait(false));
}
else if (symbol.Kind == SymbolKind.Method)
{
// There is a serialization constructor but with incorrect accessibility. Set that right.
var methodSymbol = symbol as IMethodSymbol;
// This would be constructor and can have only one definition.
Debug.Assert(methodSymbol.IsConstructor() && methodSymbol.DeclaringSyntaxReferences.Count() == 1);
var declaration = await methodSymbol.DeclaringSyntaxReferences.First().GetSyntaxAsync(cancellationToken);
var newAccessibility = methodSymbol.ContainingType.IsSealed ? Accessibility.Private : Accessibility.Protected;
var newDecl = CodeGenerator.UpdateDeclarationAccessibility(declaration, document.Project.Solution.Workspace, newAccessibility, cancellationToken: cancellationToken);
return(document.WithSyntaxRoot(root.ReplaceNode(declaration, newDecl)));
}
return(document);
}
public static async Task <IMethodSymbol> OverrideMethodAsync(
this SyntaxGenerator codeFactory,
IMethodSymbol overriddenMethod,
DeclarationModifiers modifiers,
INamedTypeSymbol newContainingType,
Document newDocument,
CancellationToken cancellationToken)
{
// Abstract: Throw not implemented
if (overriddenMethod.IsAbstract)
{
var compilation = await newDocument.Project.GetCompilationAsync(cancellationToken).ConfigureAwait(false);
var statement = codeFactory.CreateThrowNotImplementedStatement(compilation);
return(CodeGenerationSymbolFactory.CreateMethodSymbol(
overriddenMethod,
accessibility: overriddenMethod.ComputeResultantAccessibility(newContainingType),
modifiers: modifiers,
statements: ImmutableArray.Create(statement)));
}
else
{
// Otherwise, call the base method with the same parameters
var typeParams = overriddenMethod.GetTypeArguments();
var body = codeFactory.InvocationExpression(
codeFactory.MemberAccessExpression(codeFactory.BaseExpression(),
typeParams.IsDefaultOrEmpty
? codeFactory.IdentifierName(overriddenMethod.Name)
: codeFactory.GenericName(overriddenMethod.Name, typeParams)),
codeFactory.CreateArguments(overriddenMethod.GetParameters()));
return(CodeGenerationSymbolFactory.CreateMethodSymbol(
method: overriddenMethod,
accessibility: overriddenMethod.ComputeResultantAccessibility(newContainingType),
modifiers: modifiers,
statements: overriddenMethod.ReturnsVoid
? ImmutableArray.Create(codeFactory.ExpressionStatement(body))
: ImmutableArray.Create(codeFactory.ReturnStatement(body))));
}
}
private IMethodSymbol GetMethodSymbol(
SemanticDocument document,
string eventHandlerMethodName,
AssignmentExpressionSyntax eventHookupExpression,
CancellationToken cancellationToken)
{
var semanticModel = document.SemanticModel as SemanticModel;
var symbolInfo = semanticModel.GetSymbolInfo(eventHookupExpression.Left, cancellationToken);
var symbol = symbolInfo.Symbol;
if (symbol == null || symbol.Kind != SymbolKind.Event)
{
return(null);
}
var typeInference = document.Project.LanguageServices.GetService <ITypeInferenceService>();
var delegateType = typeInference.InferDelegateType(semanticModel, eventHookupExpression.Right, cancellationToken);
if (delegateType == null || delegateType.DelegateInvokeMethod == null)
{
return(null);
}
var syntaxFactory = document.Project.LanguageServices.GetService <SyntaxGenerator>();
return(CodeGenerationSymbolFactory.CreateMethodSymbol(
attributes: null,
accessibility: Accessibility.Private,
modifiers: new DeclarationModifiers(isStatic: eventHookupExpression.IsInStaticContext()),
returnType: delegateType.DelegateInvokeMethod.ReturnType,
returnsByRef: delegateType.DelegateInvokeMethod.ReturnsByRef,
explicitInterfaceSymbol: null,
name: eventHandlerMethodName,
typeParameters: null,
parameters: delegateType.DelegateInvokeMethod.Parameters,
statements: new List <SyntaxNode>
{
CodeGenerationHelpers.GenerateThrowStatement(syntaxFactory, document, "System.NotImplementedException", cancellationToken)
}));
}
private IPropertySymbol CreateProperty(
IParameterSymbol parameter, ImmutableArray <NamingRule> rules, List <string> parameterNameParts)
{
foreach (var rule in rules)
{
if (rule.SymbolSpecification.AppliesTo(SymbolKind.Property, Accessibility.Public))
{
var uniqueName = GenerateUniqueName(parameter, parameterNameParts, rule);
var getMethod = CodeGenerationSymbolFactory.CreateAccessorSymbol(
default(ImmutableArray <AttributeData>),
Accessibility.Public,
default(ImmutableArray <SyntaxNode>));
return(CodeGenerationSymbolFactory.CreatePropertySymbol(
default(ImmutableArray <AttributeData>),
Accessibility.Public,
new DeclarationModifiers(),
parameter.Type,
returnsByRef: false,
explicitInterfaceImplementations: default,
protected ImmutableArray <IParameterSymbol> DetermineParameters(
ImmutableArray <ISymbol> selectedMembers)
{
var parameters = ArrayBuilder <IParameterSymbol> .GetInstance();
foreach (var symbol in selectedMembers)
{
var type = symbol is IFieldSymbol
? ((IFieldSymbol)symbol).Type
: ((IPropertySymbol)symbol).Type;
parameters.Add(CodeGenerationSymbolFactory.CreateParameterSymbol(
attributes: default(ImmutableArray <AttributeData>),
refKind: RefKind.None,
isParams: false,
type: type,
name: symbol.Name.ToCamelCase().TrimStart(s_underscore)));
}
return(parameters.ToImmutableAndFree());
}
protected List <IParameterSymbol> DetermineParameters(
IList <ISymbol> selectedMembers)
{
var parameters = new List <IParameterSymbol>();
foreach (var symbol in selectedMembers)
{
var type = symbol is IFieldSymbol
? ((IFieldSymbol)symbol).Type
: ((IPropertySymbol)symbol).Type;
parameters.Add(CodeGenerationSymbolFactory.CreateParameterSymbol(
attributes: null,
refKind: RefKind.None,
isParams: false,
type: type,
name: symbol.Name.ToCamelCase()));
}
return(parameters);
}
private static IMethodSymbol GenerateMethodSymbol(
INamedTypeSymbol typeToGenerateIn, INamedTypeSymbol parameterSymbol)
{
// Remove any generic parameters
if (typeToGenerateIn.IsGenericType)
{
typeToGenerateIn = typeToGenerateIn.ConstructUnboundGenericType().ConstructedFrom;
}
return(CodeGenerationSymbolFactory.CreateMethodSymbol(
attributes: ImmutableArray <AttributeData> .Empty,
accessibility: default(Accessibility),
modifiers: default(DeclarationModifiers),
returnType: typeToGenerateIn,
returnsByRef: false,
explicitInterfaceSymbol: null,
name: null,
typeParameters: ImmutableArray <ITypeParameterSymbol> .Empty,
parameters: ImmutableArray.Create(CodeGenerationSymbolFactory.CreateParameterSymbol(parameterSymbol, "v")),
methodKind: MethodKind.Conversion));
}
private IFieldSymbol CreateField(
IParameterSymbol parameter, ImmutableArray <NamingRule> rules, List <string> parameterNameParts)
{
foreach (var rule in rules)
{
if (rule.SymbolSpecification.AppliesTo(SymbolKind.Field, Accessibility.Private))
{
var uniqueName = GenerateUniqueName(parameter, parameterNameParts, rule);
return(CodeGenerationSymbolFactory.CreateFieldSymbol(
default(ImmutableArray <AttributeData>),
Accessibility.Private,
DeclarationModifiers.ReadOnly,
parameter.Type, uniqueName));
}
}
// We place a special rule in s_builtInRules that matches all fields. So we should
// always find a matching rule.
throw ExceptionUtilities.Unreachable;
}
internal static async Task TestAddNamespaceAsync(
string initial,
string expected,
string name = "N",
IList <ISymbol> imports = null,
IList <INamespaceOrTypeSymbol> members = null,
CodeGenerationContext context = null)
{
using var testContext = await TestContext.CreateAsync(initial, expected);
var @namespace = CodeGenerationSymbolFactory.CreateNamespaceSymbol(name, imports, members);
testContext.Result = await testContext.Service.AddNamespaceAsync(
new CodeGenerationSolutionContext(
testContext.Solution,
context ?? CodeGenerationContext.Default,
testContext.Workspace.GlobalOptions.CreateProvider()),
(INamespaceSymbol)testContext.GetDestination(),
@namespace,
CancellationToken.None);
}
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 TestAddUnsupportedOperatorAsync(
string initial,
CodeGenerationOperatorKind operatorKind,
Accessibility accessibility = Accessibility.Public,
DeclarationModifiers modifiers = default(DeclarationModifiers),
Type returnType = null,
IList <Func <SemanticModel, IParameterSymbol> > parameters = null,
string statements = null,
CodeGenerationOptions codeGenerationOptions = default(CodeGenerationOptions),
bool compareTokens = 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(
null,
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.CannotCodeGenUnsupportedOperator, 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));
}
}
private ISymbol GenerateProperty(
Compilation compilation,
IPropertySymbol property,
Accessibility accessibility,
DeclarationModifiers modifiers,
bool generateAbstractly,
bool useExplicitInterfaceSymbol,
string memberName,
ImplementTypePropertyGenerationBehavior propertyGenerationBehavior,
CancellationToken cancellationToken)
{
var factory = this.Document.GetLanguageService <SyntaxGenerator>();
var attributesToRemove = AttributesToRemove(compilation);
var getAccessor = GenerateGetAccessor(
compilation, property, accessibility, generateAbstractly, useExplicitInterfaceSymbol,
propertyGenerationBehavior, attributesToRemove, cancellationToken);
var setAccessor = GenerateSetAccessor(
compilation, property, accessibility, generateAbstractly, useExplicitInterfaceSymbol,
propertyGenerationBehavior, attributesToRemove, cancellationToken);
var syntaxFacts = Document.GetLanguageService <ISyntaxFactsService>();
var parameterNames = NameGenerator.EnsureUniqueness(
property.Parameters.Select(p => p.Name).ToList(), isCaseSensitive: syntaxFacts.IsCaseSensitive);
var updatedProperty = property.RenameParameters(parameterNames);
updatedProperty = updatedProperty.RemoveAttributeFromParameters(attributesToRemove);
// TODO(cyrusn): Delegate through throughMember if it's non-null.
return(CodeGenerationSymbolFactory.CreatePropertySymbol(
updatedProperty,
accessibility: accessibility,
modifiers: modifiers,
explicitInterfaceSymbol: useExplicitInterfaceSymbol ? property : null,
name: memberName,
getMethod: getAccessor,
setMethod: setAccessor));
}
protected ImmutableArray <ITypeParameterSymbol> CreateMethodTypeParameters()
{
if (AnalyzerResult.MethodTypeParametersInDeclaration.Count == 0)
{
return(ImmutableArray <ITypeParameterSymbol> .Empty);
}
var set = new HashSet <ITypeParameterSymbol>(
AnalyzerResult.MethodTypeParametersInConstraintList
);
var typeParameters = ArrayBuilder <ITypeParameterSymbol> .GetInstance();
foreach (var parameter in AnalyzerResult.MethodTypeParametersInDeclaration)
{
if (parameter != null && set.Contains(parameter))
{
typeParameters.Add(parameter);
continue;
}
typeParameters.Add(
CodeGenerationSymbolFactory.CreateTypeParameter(
parameter.GetAttributes(),
parameter.Variance,
parameter.Name,
ImmutableArray.Create <ITypeSymbol>(),
parameter.NullableAnnotation,
parameter.HasConstructorConstraint,
parameter.HasReferenceTypeConstraint,
parameter.HasUnmanagedTypeConstraint,
parameter.HasValueTypeConstraint,
parameter.HasNotNullConstraint,
parameter.Ordinal
)
);
}
return(typeParameters.ToImmutableAndFree());
}
internal static async Task TestAddMethodAsync(
string initial,
string expected,
string name = "M",
Accessibility accessibility = Accessibility.Public,
DeclarationModifiers modifiers = default(DeclarationModifiers),
Type returnType = null,
Func <SemanticModel, IMethodSymbol> explicitInterface = null,
IList <ITypeParameterSymbol> typeParameters = null,
IList <Func <SemanticModel, IParameterSymbol> > parameters = null,
string statements = null,
IList <SyntaxNode> handlesExpressions = null,
CodeGenerationOptions codeGenerationOptions = default(CodeGenerationOptions),
bool compareTokens = true)
{
if (statements != null)
{
expected = expected.Replace("$$", statements);
}
using (var context = await TestContext.CreateAsync(initial, expected, compareTokens))
{
var parameterSymbols = GetParameterSymbols(parameters, context);
var parsedStatements = context.ParseStatements(statements);
var explicitInterfaceSymbol = GetMethodSymbol(explicitInterface, context);
var method = CodeGenerationSymbolFactory.CreateMethodSymbol(
null,
accessibility,
modifiers,
GetTypeSymbol(returnType)(context.SemanticModel),
false,
explicitInterfaceSymbol,
name,
typeParameters,
parameterSymbols,
parsedStatements,
handlesExpressions: handlesExpressions);
context.Result = await context.Service.AddMethodAsync(context.Solution, (INamedTypeSymbol)context.GetDestination(), method, codeGenerationOptions);
}
}
private void GetParameters(
ImmutableArray <TArgumentSyntax> arguments,
ImmutableArray <TAttributeArgumentSyntax>?attributeArguments,
ImmutableArray <ITypeSymbol> parameterTypes,
ImmutableArray <ParameterName> parameterNames,
out Dictionary <string, ISymbol> parameterToExistingFieldMap,
out Dictionary <string, string> parameterToNewFieldMap,
out ImmutableArray <IParameterSymbol> parameters)
{
parameterToExistingFieldMap = new Dictionary <string, ISymbol>();
parameterToNewFieldMap = new Dictionary <string, string>();
var result = ArrayBuilder <IParameterSymbol> .GetInstance();
for (var i = 0; i < parameterNames.Length; i++)
{
// See if there's a matching field we can use. First test in a case sensitive
// manner, then case insensitively.
if (!TryFindMatchingField(
arguments, attributeArguments, parameterNames, parameterTypes, i, parameterToExistingFieldMap,
parameterToNewFieldMap, caseSensitive: true, newParameterNames: out parameterNames))
{
if (!TryFindMatchingField(arguments, attributeArguments, parameterNames, parameterTypes, i, parameterToExistingFieldMap,
parameterToNewFieldMap, caseSensitive: false, newParameterNames: out parameterNames))
{
parameterToNewFieldMap[parameterNames[i].BestNameForParameter] =
parameterNames[i].NameBasedOnArgument;
}
}
result.Add(CodeGenerationSymbolFactory.CreateParameterSymbol(
attributes: default(ImmutableArray <AttributeData>),
refKind: _service.GetRefKind(arguments[i]),
isParams: false,
type: parameterTypes[i],
name: parameterNames[i].BestNameForParameter));
}
parameters = result.ToImmutableAndFree();
}
