private static SyntaxTokenList GenerateModifiers(
IEventSymbol @event, CodeGenerationDestination destination, CSharpCodeGenerationContextInfo info)
{
var tokens = ArrayBuilder <SyntaxToken> .GetInstance();
// Most modifiers not allowed if we're an explicit impl.
if ([email protected]())
{
// If we're generating into an interface, then allow modifiers for static abstract members
if (destination is CodeGenerationDestination.InterfaceType)
{
if (@event.IsStatic)
{
tokens.Add(SyntaxFactory.Token(SyntaxKind.StaticKeyword));
// We only generate the abstract keyword in interfaces for static abstract members
if (@event.IsAbstract)
{
tokens.Add(SyntaxFactory.Token(SyntaxKind.AbstractKeyword));
}
}
}
else
{
AddAccessibilityModifiers(@event.DeclaredAccessibility, tokens, info, Accessibility.Private);
if (@event.IsStatic)
{
tokens.Add(SyntaxFactory.Token(SyntaxKind.StaticKeyword));
}
// An event is readonly if its accessors are readonly.
// If one accessor is readonly and the other one is not,
// the event is malformed and cannot be properly displayed.
// See https://github.com/dotnet/roslyn/issues/34213
// Don't show the readonly modifier if the containing type is already readonly
if (@event.AddMethod?.IsReadOnly == true && [email protected])
{
tokens.Add(SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword));
}
if (@event.IsAbstract)
{
tokens.Add(SyntaxFactory.Token(SyntaxKind.AbstractKeyword));
}
if (@event.IsOverride)
{
tokens.Add(SyntaxFactory.Token(SyntaxKind.OverrideKeyword));
}
}
}
if (CodeGenerationEventInfo.GetIsUnsafe(@event))
{
tokens.Add(SyntaxFactory.Token(SyntaxKind.UnsafeKeyword));
}
return(tokens.ToSyntaxTokenListAndFree());
}
private static AttributeSyntax?TryGenerateAttribute(AttributeData attribute, CSharpCodeGenerationContextInfo info)
{
if (IsCompilerInternalAttribute(attribute))
{
return(null);
}
if (!info.Context.MergeAttributes)
{
var reusableSyntax = GetReuseableSyntaxNodeForAttribute <AttributeSyntax>(attribute, info);
if (reusableSyntax != null)
{
return(reusableSyntax);
}
}
if (attribute.AttributeClass == null)
{
return(null);
}
var attributeArguments = GenerateAttributeArgumentList(attribute);
return(attribute.AttributeClass.GenerateTypeSyntax() is NameSyntax nameSyntax
? SyntaxFactory.Attribute(nameSyntax, attributeArguments)
: null);
}
public static BracketedParameterListSyntax GenerateBracketedParameterList(
ImmutableArray <IParameterSymbol> parameterDefinitions,
bool isExplicit,
CSharpCodeGenerationContextInfo info)
{
return(GenerateBracketedParameterList((IList <IParameterSymbol>)parameterDefinitions, isExplicit, info));
}
public static SyntaxList <AttributeListSyntax> GenerateAttributeLists(
ImmutableArray <AttributeData> attributes,
CSharpCodeGenerationContextInfo info,
SyntaxToken?target = null)
{
if (info.Context.MergeAttributes)
{
var attributeNodes =
attributes.OrderBy(a => a.AttributeClass?.Name)
.Select(a => TryGenerateAttribute(a, info))
.WhereNotNull().ToList();
return(attributeNodes.Count == 0
? default
: SyntaxFactory.SingletonList(SyntaxFactory.AttributeList(
target.HasValue ? SyntaxFactory.AttributeTargetSpecifier(target.Value) : null,
SyntaxFactory.SeparatedList(attributeNodes))));
}
else
{
var attributeDeclarations =
attributes.OrderBy(a => a.AttributeClass?.Name)
.Select(a => TryGenerateAttributeDeclaration(a, target, info))
.WhereNotNull().ToList();
return(attributeDeclarations.Count == 0
? default
: SyntaxFactory.List <AttributeListSyntax>(attributeDeclarations));
}
}
private static SyntaxTokenList GenerateModifiers(IFieldSymbol field, CSharpCodeGenerationContextInfo info)
{
var tokens = ArrayBuilder <SyntaxToken> .GetInstance();
AddAccessibilityModifiers(field.DeclaredAccessibility, tokens, info, Accessibility.Private);
if (field.IsConst)
{
tokens.Add(SyntaxFactory.Token(SyntaxKind.ConstKeyword));
}
else
{
if (field.IsStatic)
{
tokens.Add(SyntaxFactory.Token(SyntaxKind.StaticKeyword));
}
if (field.IsReadOnly)
{
tokens.Add(SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword));
}
if (field.IsRequired)
{
tokens.Add(SyntaxFactory.Token(SyntaxKind.RequiredKeyword));
}
}
if (CodeGenerationFieldInfo.GetIsUnsafe(field))
{
tokens.Add(SyntaxFactory.Token(SyntaxKind.UnsafeKeyword));
}
return(tokens.ToSyntaxTokenListAndFree());
}
public static FieldDeclarationSyntax GenerateFieldDeclaration(
IFieldSymbol field, CSharpCodeGenerationContextInfo info, CancellationToken cancellationToken)
{
var reusableSyntax = GetReuseableSyntaxNodeForSymbol <FieldDeclarationSyntax>(field, info);
if (reusableSyntax != null)
{
return(reusableSyntax);
}
var initializer = CodeGenerationFieldInfo.GetInitializer(field) is ExpressionSyntax initializerNode
? SyntaxFactory.EqualsValueClause(initializerNode)
: GenerateEqualsValue(field);
var fieldDeclaration = SyntaxFactory.FieldDeclaration(
AttributeGenerator.GenerateAttributeLists(field.GetAttributes(), info),
GenerateModifiers(field, info),
SyntaxFactory.VariableDeclaration(
field.Type.GenerateTypeSyntax(),
SyntaxFactory.SingletonSeparatedList(
AddAnnotationsTo(field, SyntaxFactory.VariableDeclarator(field.Name.ToIdentifierToken(), null, initializer)))));
return(AddFormatterAndCodeGeneratorAnnotationsTo(
ConditionallyAddDocumentationCommentTo(fieldDeclaration, field, info, cancellationToken)));
}
private static OperatorDeclarationSyntax GenerateOperatorDeclarationWorker(
IMethodSymbol method,
CodeGenerationDestination destination,
CSharpCodeGenerationContextInfo info)
{
var hasNoBody = !info.Context.GenerateMethodBodies || method.IsExtern || method.IsAbstract;
var operatorSyntaxKind = SyntaxFacts.GetOperatorKind(method.MetadataName);
if (operatorSyntaxKind == SyntaxKind.None)
{
throw new ArgumentException(string.Format(WorkspacesResources.Cannot_generate_code_for_unsupported_operator_0, method.Name), nameof(method));
}
var operatorToken = SyntaxFactory.Token(operatorSyntaxKind);
var checkedToken = SyntaxFacts.IsCheckedOperator(method.MetadataName)
? SyntaxFactory.Token(SyntaxKind.CheckedKeyword)
: default;
var operatorDecl = SyntaxFactory.OperatorDeclaration(
attributeLists: AttributeGenerator.GenerateAttributeLists(method.GetAttributes(), info),
modifiers: GenerateModifiers(method, destination, hasNoBody),
returnType: method.ReturnType.GenerateTypeSyntax(),
explicitInterfaceSpecifier: GenerateExplicitInterfaceSpecifier(method.ExplicitInterfaceImplementations),
operatorKeyword: SyntaxFactory.Token(SyntaxKind.OperatorKeyword),
checkedKeyword: checkedToken,
operatorToken: operatorToken,
parameterList: ParameterGenerator.GenerateParameterList(method.Parameters, isExplicit: false, info: info),
body: hasNoBody ? null : StatementGenerator.GenerateBlock(method),
expressionBody: null,
semicolonToken: hasNoBody ? SyntaxFactory.Token(SyntaxKind.SemicolonToken) : new SyntaxToken());
operatorDecl = UseExpressionBodyIfDesired(info, operatorDecl);
return(operatorDecl);
}
private static RecordDeclarationSyntax GenerateRecordMembers(
ICodeGenerationService service,
CSharpCodeGenerationContextInfo info,
RecordDeclarationSyntax recordDeclaration,
ImmutableArray <ISymbol> members,
CancellationToken cancellationToken)
{
if (!info.Context.GenerateMembers)
{
members = ImmutableArray <ISymbol> .Empty;
}
// For a record, add record parameters if we have a primary constructor.
var primaryConstructor = members.OfType <IMethodSymbol>().FirstOrDefault(m => CodeGenerationConstructorInfo.GetIsPrimaryConstructor(m));
if (primaryConstructor != null)
{
var parameterList = ParameterGenerator.GenerateParameterList(primaryConstructor.Parameters, isExplicit: false, info);
recordDeclaration = recordDeclaration.WithParameterList(parameterList);
// remove the primary constructor from the list of members to generate.
members = members.Remove(primaryConstructor);
// remove any fields/properties that were created by the primary constructor
members = members.WhereAsArray(m => m is not IPropertySymbol and not IFieldSymbol || !primaryConstructor.Parameters.Any(static (p, m) => p.Name == m.Name, m));
private static MemberDeclarationSyntax GeneratePropertyDeclaration(
IPropertySymbol property, CodeGenerationDestination destination,
CSharpCodeGenerationContextInfo info)
{
var initializer = CodeGenerationPropertyInfo.GetInitializer(property) is ExpressionSyntax initializerNode
? SyntaxFactory.EqualsValueClause(initializerNode)
: null;
var explicitInterfaceSpecifier = GenerateExplicitInterfaceSpecifier(property.ExplicitInterfaceImplementations);
var accessorList = GenerateAccessorList(property, destination, info);
var propertyDeclaration = SyntaxFactory.PropertyDeclaration(
attributeLists: AttributeGenerator.GenerateAttributeLists(property.GetAttributes(), info),
modifiers: GenerateModifiers(property, destination, info),
type: GenerateTypeSyntax(property),
explicitInterfaceSpecifier: explicitInterfaceSpecifier,
identifier: property.Name.ToIdentifierToken(),
accessorList: accessorList,
expressionBody: null,
initializer: initializer);
propertyDeclaration = UseExpressionBodyIfDesired(info, propertyDeclaration);
return(AddFormatterAndCodeGeneratorAnnotationsTo(
AddAnnotationsTo(property, propertyDeclaration)));
}
public static TypeParameterListSyntax?GenerateTypeParameterList(
ImmutableArray <ITypeParameterSymbol> typeParameters, CSharpCodeGenerationContextInfo info)
{
return(typeParameters.Length == 0
? null
: SyntaxFactory.TypeParameterList(
SyntaxFactory.SeparatedList(typeParameters.Select(t => GenerateTypeParameter(t, info)))));
}
public static ParameterListSyntax GenerateParameterList(
IEnumerable <IParameterSymbol> parameterDefinitions,
bool isExplicit,
CSharpCodeGenerationContextInfo info)
{
var parameters = GetParameters(parameterDefinitions, isExplicit, info);
return(SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList(parameters)));
}
internal static ConversionOperatorDeclarationSyntax GenerateConversionDeclaration(
IMethodSymbol method,
CodeGenerationDestination destination,
CSharpCodeGenerationContextInfo info,
CancellationToken cancellationToken)
{
var declaration = GenerateConversionDeclarationWorker(method, destination, info);
return(AddFormatterAndCodeGeneratorAnnotationsTo(AddAnnotationsTo(method,
ConditionallyAddDocumentationCommentTo(declaration, method, info, cancellationToken))));
}
public static SyntaxNode UpdateCompilationUnitOrNamespaceDeclaration(
ICodeGenerationService service,
SyntaxNode declaration,
IList <ISymbol> newMembers,
CSharpCodeGenerationContextInfo info,
CancellationToken cancellationToken)
{
declaration = RemoveAllMembers(declaration);
declaration = service.AddMembers(declaration, newMembers, info, cancellationToken);
return(AddFormatterAndCodeGeneratorAnnotationsTo(declaration));
}
private static AccessorListSyntax GenerateAccessorList(
IEventSymbol @event, CodeGenerationDestination destination, CSharpCodeGenerationContextInfo info)
{
var accessors = new List <AccessorDeclarationSyntax?>
{
GenerateAccessorDeclaration(@event, @event.AddMethod, SyntaxKind.AddAccessorDeclaration, destination, info),
GenerateAccessorDeclaration(@event, @event.RemoveMethod, SyntaxKind.RemoveAccessorDeclaration, destination, info),
};
return(SyntaxFactory.AccessorList(accessors.WhereNotNull().ToSyntaxList()));
}
public static BracketedParameterListSyntax GenerateBracketedParameterList(
IEnumerable <IParameterSymbol> parameterDefinitions,
bool isExplicit,
CSharpCodeGenerationContextInfo info)
{
// Bracketed parameter lists come from indexers. Those don't have type parameters, so we
// could never have a typeParameterMapping.
var parameters = GetParameters(parameterDefinitions, isExplicit, info);
return(SyntaxFactory.BracketedParameterList(
parameters: SyntaxFactory.SeparatedList(parameters)));
}
private static MemberDeclarationSyntax GenerateEventFieldDeclaration(
IEventSymbol @event, CodeGenerationDestination destination, CSharpCodeGenerationContextInfo info)
{
return(AddFormatterAndCodeGeneratorAnnotationsTo(
AddAnnotationsTo(@event,
SyntaxFactory.EventFieldDeclaration(
AttributeGenerator.GenerateAttributeLists(@event.GetAttributes(), info),
GenerateModifiers(@event, destination, info),
SyntaxFactory.VariableDeclaration(
@event.Type.GenerateTypeSyntax(),
SyntaxFactory.SingletonSeparatedList(SyntaxFactory.VariableDeclarator(@event.Name.ToIdentifierToken())))))));
}
internal static TypeDeclarationSyntax AddConversionTo(
TypeDeclarationSyntax destination,
IMethodSymbol method,
CSharpCodeGenerationContextInfo info,
IList <bool>?availableIndices,
CancellationToken cancellationToken)
{
var methodDeclaration = GenerateConversionDeclaration(method, GetDestination(destination), info, cancellationToken);
var members = Insert(destination.Members, methodDeclaration, info, availableIndices, after: LastOperator);
return(AddMembersTo(destination, members, cancellationToken));
}
private static AccessorDeclarationSyntax?GenerateAccessorDeclaration(
IEventSymbol @event,
IMethodSymbol?accessor,
SyntaxKind kind,
CodeGenerationDestination destination,
CSharpCodeGenerationContextInfo info)
{
var hasBody = info.Context.GenerateMethodBodies && HasAccessorBodies(@event, destination, accessor);
return(accessor == null
? null
: GenerateAccessorDeclaration(accessor, kind, hasBody));
}
private static MemberDeclarationSyntax GenerateEventDeclarationWorker(
IEventSymbol @event, CodeGenerationDestination destination, CSharpCodeGenerationContextInfo info)
{
var explicitInterfaceSpecifier = GenerateExplicitInterfaceSpecifier(@event.ExplicitInterfaceImplementations);
return(AddFormatterAndCodeGeneratorAnnotationsTo(SyntaxFactory.EventDeclaration(
attributeLists: AttributeGenerator.GenerateAttributeLists(@event.GetAttributes(), info),
modifiers: GenerateModifiers(@event, destination, info),
type: @event.Type.GenerateTypeSyntax(),
explicitInterfaceSpecifier: explicitInterfaceSpecifier,
identifier: @event.Name.ToIdentifierToken(),
accessorList: GenerateAccessorList(@event, destination, info))));
}
internal static BaseNamespaceDeclarationSyntax AddMethodTo(
BaseNamespaceDeclarationSyntax destination,
IMethodSymbol method,
CSharpCodeGenerationContextInfo info,
IList <bool>?availableIndices,
CancellationToken cancellationToken)
{
var declaration = GenerateMethodDeclaration(method, CodeGenerationDestination.Namespace, info, cancellationToken);
var members = Insert(destination.Members, declaration, info, availableIndices, after: LastMethod);
return(destination.WithMembers(members.ToSyntaxList()));
}
private static AttributeListSyntax?TryGenerateAttributeDeclaration(
AttributeData attribute, SyntaxToken?target, CSharpCodeGenerationContextInfo info)
{
var attributeSyntax = TryGenerateAttribute(attribute, info);
return(attributeSyntax == null
? null
: SyntaxFactory.AttributeList(
target.HasValue
? SyntaxFactory.AttributeTargetSpecifier(target.Value)
: null,
SyntaxFactory.SingletonSeparatedList(attributeSyntax)));
}
private static SyntaxNode GetDeclarationSyntaxWithoutMembers(
INamespaceSymbol @namespace,
INamespaceSymbol innermostNamespace,
string name,
CodeGenerationDestination destination,
CSharpCodeGenerationContextInfo info)
{
var reusableSyntax = GetReuseableSyntaxNodeForSymbol <SyntaxNode>(@namespace, info);
return(reusableSyntax == null
? GenerateNamespaceDeclarationWorker(name, innermostNamespace, destination, info)
: RemoveAllMembers(reusableSyntax));
}
public static TypeDeclarationSyntax AddNamedTypeTo(
ICodeGenerationService service,
TypeDeclarationSyntax destination,
INamedTypeSymbol namedType,
CSharpCodeGenerationContextInfo info,
IList <bool>?availableIndices,
CancellationToken cancellationToken)
{
var declaration = GenerateNamedTypeDeclaration(service, namedType, GetDestination(destination), info, cancellationToken);
var members = Insert(destination.Members, declaration, info, availableIndices);
return(AddMembersTo(destination, members, cancellationToken));
}
public static CompilationUnitSyntax AddNamedTypeTo(
ICodeGenerationService service,
CompilationUnitSyntax destination,
INamedTypeSymbol namedType,
CSharpCodeGenerationContextInfo info,
IList <bool>?availableIndices,
CancellationToken cancellationToken)
{
var declaration = GenerateNamedTypeDeclaration(service, namedType, CodeGenerationDestination.CompilationUnit, info, cancellationToken);
var members = Insert(destination.Members, declaration, info, availableIndices);
return(destination.WithMembers(members));
}
internal static DestructorDeclarationSyntax GenerateDestructorDeclaration(
IMethodSymbol destructor, CSharpCodeGenerationContextInfo info, CancellationToken cancellationToken)
{
var reusableSyntax = GetReuseableSyntaxNodeForSymbol <DestructorDeclarationSyntax>(destructor, info);
if (reusableSyntax != null)
{
return(reusableSyntax);
}
var hasNoBody = !info.Context.GenerateMethodBodies;
var declaration = SyntaxFactory.DestructorDeclaration(
attributeLists: AttributeGenerator.GenerateAttributeLists(destructor.GetAttributes(), info),
modifiers: default,
internal static ParameterSyntax GetParameter(IParameterSymbol p, CSharpCodeGenerationContextInfo info, bool isExplicit, bool isFirstParam, bool seenOptional)
{
var reusableSyntax = GetReuseableSyntaxNodeForSymbol <ParameterSyntax>(p, info);
if (reusableSyntax != null)
{
return(reusableSyntax);
}
return(SyntaxFactory.Parameter(p.Name.ToIdentifierToken())
.WithAttributeLists(GenerateAttributes(p, isExplicit, info))
.WithModifiers(GenerateModifiers(p, isFirstParam))
.WithType(p.Type.GenerateTypeSyntax())
.WithDefault(GenerateEqualsValueClause(p, isExplicit, seenOptional)));
}
internal static TypeDeclarationSyntax AddMethodTo(
TypeDeclarationSyntax destination,
IMethodSymbol method,
CSharpCodeGenerationContextInfo info,
IList <bool>?availableIndices,
CancellationToken cancellationToken)
{
var methodDeclaration = GenerateMethodDeclaration(
method, GetDestination(destination), info, cancellationToken);
// Create a clone of the original type with the new method inserted.
var members = Insert(destination.Members, methodDeclaration, info, availableIndices, after: LastMethod);
return(AddMembersTo(destination, members, cancellationToken));
}
public static BaseNamespaceDeclarationSyntax AddNamedTypeTo(
ICodeGenerationService service,
BaseNamespaceDeclarationSyntax destination,
INamedTypeSymbol namedType,
CSharpCodeGenerationContextInfo info,
IList <bool>?availableIndices,
CancellationToken cancellationToken)
{
var declaration = GenerateNamedTypeDeclaration(service, namedType, CodeGenerationDestination.Namespace, info, cancellationToken);
var members = Insert(destination.Members, declaration, info, availableIndices);
return(ConditionallyAddFormattingAnnotationTo(
destination.WithMembers(members),
members));
}
private static AccessorListSyntax?GenerateAccessorList(
IPropertySymbol property, CodeGenerationDestination destination,
CSharpCodeGenerationContextInfo info)
{
var setAccessorKind = property.SetMethod?.IsInitOnly == true ? SyntaxKind.InitAccessorDeclaration : SyntaxKind.SetAccessorDeclaration;
var accessors = new[]
{
GenerateAccessorDeclaration(property, property.GetMethod, SyntaxKind.GetAccessorDeclaration, destination, info),
GenerateAccessorDeclaration(property, property.SetMethod, setAccessorKind, destination, info),
};
return(accessors[0] == null && accessors[1] == null
? null
: SyntaxFactory.AccessorList(accessors.WhereNotNull().ToSyntaxList()));
}
internal static TypeDeclarationSyntax AddDestructorTo(
TypeDeclarationSyntax destination,
IMethodSymbol destructor,
CSharpCodeGenerationContextInfo info,
IList <bool>?availableIndices,
CancellationToken cancellationToken)
{
var destructorDeclaration = GenerateDestructorDeclaration(destructor, info, cancellationToken);
// Generate after the last constructor, or after the last field, or at the start of the
// type.
var members = Insert(destination.Members, destructorDeclaration, info,
availableIndices, after: LastConstructorOrField, before: FirstMember);
return(AddMembersTo(destination, members, cancellationToken));
}