public static BracketedParameterListSyntax GenerateBracketedParameterList(
ImmutableArray <IParameterSymbol> parameterDefinitions,
bool isExplicit,
CSharpCodeGenerationOptions options)
{
return(GenerateBracketedParameterList((IList <IParameterSymbol>)parameterDefinitions, isExplicit, options));
}
private static SyntaxTokenList GenerateModifiers(IFieldSymbol field, CSharpCodeGenerationOptions options)
{
var tokens = ArrayBuilder <SyntaxToken> .GetInstance();
AddAccessibilityModifiers(field.DeclaredAccessibility, tokens, options, 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 (CodeGenerationFieldInfo.GetIsUnsafe(field))
{
tokens.Add(SyntaxFactory.Token(SyntaxKind.UnsafeKeyword));
}
return(tokens.ToSyntaxTokenListAndFree());
}
public static FieldDeclarationSyntax GenerateFieldDeclaration(
IFieldSymbol field, CSharpCodeGenerationOptions options, CancellationToken cancellationToken)
{
var reusableSyntax = GetReuseableSyntaxNodeForSymbol <FieldDeclarationSyntax>(field, options);
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(), options),
GenerateModifiers(field, options),
SyntaxFactory.VariableDeclaration(
field.Type.GenerateTypeSyntax(),
SyntaxFactory.SingletonSeparatedList(
AddAnnotationsTo(field, SyntaxFactory.VariableDeclarator(field.Name.ToIdentifierToken(), null, initializer)))));
return(AddFormatterAndCodeGeneratorAnnotationsTo(
ConditionallyAddDocumentationCommentTo(fieldDeclaration, field, options, cancellationToken)));
}
public static SyntaxList <AttributeListSyntax> GenerateAttributeLists(
ImmutableArray <AttributeData> attributes,
CSharpCodeGenerationOptions options,
SyntaxToken?target = null)
{
if (options.Context.MergeAttributes)
{
var attributeNodes =
attributes.OrderBy(a => a.AttributeClass?.Name)
.Select(a => TryGenerateAttribute(a, options))
.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, options))
.WhereNotNull().ToList();
return(attributeDeclarations.Count == 0
? default
: SyntaxFactory.List <AttributeListSyntax>(attributeDeclarations));
}
}
private static MemberDeclarationSyntax GeneratePropertyDeclaration(
IPropertySymbol property, CodeGenerationDestination destination,
CSharpCodeGenerationOptions options)
{
var initializer = CodeGenerationPropertyInfo.GetInitializer(property) is ExpressionSyntax initializerNode
? SyntaxFactory.EqualsValueClause(initializerNode)
: null;
var explicitInterfaceSpecifier = GenerateExplicitInterfaceSpecifier(property.ExplicitInterfaceImplementations);
var accessorList = GenerateAccessorList(property, destination, options);
var propertyDeclaration = SyntaxFactory.PropertyDeclaration(
attributeLists: AttributeGenerator.GenerateAttributeLists(property.GetAttributes(), options),
modifiers: GenerateModifiers(property, destination, options),
type: GenerateTypeSyntax(property),
explicitInterfaceSpecifier: explicitInterfaceSpecifier,
identifier: property.Name.ToIdentifierToken(),
accessorList: accessorList,
expressionBody: null,
initializer: initializer);
propertyDeclaration = UseExpressionBodyIfDesired(options, propertyDeclaration);
return(AddFormatterAndCodeGeneratorAnnotationsTo(
AddAnnotationsTo(property, propertyDeclaration)));
}
private static AttributeSyntax?TryGenerateAttribute(AttributeData attribute, CSharpCodeGenerationOptions options)
{
if (IsCompilerInternalAttribute(attribute))
{
return(null);
}
if (!options.Context.MergeAttributes)
{
var reusableSyntax = GetReuseableSyntaxNodeForAttribute <AttributeSyntax>(attribute, options);
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);
}
private static OperatorDeclarationSyntax GenerateOperatorDeclarationWorker(
IMethodSymbol method,
CSharpCodeGenerationOptions options)
{
var hasNoBody = !options.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 operatorDecl = SyntaxFactory.OperatorDeclaration(
attributeLists: AttributeGenerator.GenerateAttributeLists(method.GetAttributes(), options),
modifiers: GenerateModifiers(method),
returnType: method.ReturnType.GenerateTypeSyntax(),
explicitInterfaceSpecifier: GenerateExplicitInterfaceSpecifier(method.ExplicitInterfaceImplementations),
operatorKeyword: SyntaxFactory.Token(SyntaxKind.OperatorKeyword),
operatorToken: operatorToken,
parameterList: ParameterGenerator.GenerateParameterList(method.Parameters, isExplicit: false, options: options),
body: hasNoBody ? null : StatementGenerator.GenerateBlock(method),
expressionBody: null,
semicolonToken: hasNoBody ? SyntaxFactory.Token(SyntaxKind.SemicolonToken) : new SyntaxToken());
operatorDecl = UseExpressionBodyIfDesired(options, operatorDecl);
return(operatorDecl);
}
private static ConversionOperatorDeclarationSyntax GenerateConversionDeclarationWorker(
IMethodSymbol method,
CSharpCodeGenerationOptions options)
{
var hasNoBody = !options.Context.GenerateMethodBodies || method.IsExtern;
var reusableSyntax = GetReuseableSyntaxNodeForSymbol <ConversionOperatorDeclarationSyntax>(method, options);
if (reusableSyntax != null)
{
return(reusableSyntax);
}
var keyword = method.MetadataName == WellKnownMemberNames.ImplicitConversionName
? SyntaxFactory.Token(SyntaxKind.ImplicitKeyword)
: SyntaxFactory.Token(SyntaxKind.ExplicitKeyword);
var declaration = SyntaxFactory.ConversionOperatorDeclaration(
attributeLists: AttributeGenerator.GenerateAttributeLists(method.GetAttributes(), options),
modifiers: GenerateModifiers(),
implicitOrExplicitKeyword: keyword,
operatorKeyword: SyntaxFactory.Token(SyntaxKind.OperatorKeyword),
type: method.ReturnType.GenerateTypeSyntax(),
parameterList: ParameterGenerator.GenerateParameterList(method.Parameters, isExplicit: false, options: options),
body: hasNoBody ? null : StatementGenerator.GenerateBlock(method),
semicolonToken: hasNoBody ? SyntaxFactory.Token(SyntaxKind.SemicolonToken) : new SyntaxToken());
declaration = UseExpressionBodyIfDesired(options, declaration);
return(declaration);
}
public static TypeParameterListSyntax?GenerateTypeParameterList(
ImmutableArray <ITypeParameterSymbol> typeParameters, CSharpCodeGenerationOptions options)
{
return(typeParameters.Length == 0
? null
: SyntaxFactory.TypeParameterList(
SyntaxFactory.SeparatedList(typeParameters.Select(t => GenerateTypeParameter(t, options)))));
}
private static SyntaxTokenList GenerateModifiers(
IPropertySymbol property, CodeGenerationDestination destination, CSharpCodeGenerationOptions options)
{
var tokens = ArrayBuilder <SyntaxToken> .GetInstance();
// Most modifiers not allowed if we're an explicit impl.
if (!property.ExplicitInterfaceImplementations.Any())
{
if (destination is not CodeGenerationDestination.CompilationUnit and
not CodeGenerationDestination.InterfaceType)
{
AddAccessibilityModifiers(property.DeclaredAccessibility, tokens, options, Accessibility.Private);
if (property.IsStatic)
{
tokens.Add(SyntaxFactory.Token(SyntaxKind.StaticKeyword));
}
// note: explicit interface impls are allowed to be 'readonly' but it never actually affects callers
// because of the boxing requirement in order to call the method.
// therefore it seems like a small oversight to leave out the keyword for an explicit impl from metadata.
var hasAllReadOnlyAccessors = property.GetMethod?.IsReadOnly != false && property.SetMethod?.IsReadOnly != false;
// Don't show the readonly modifier if the containing type is already readonly
if (hasAllReadOnlyAccessors && !property.ContainingType.IsReadOnly)
{
tokens.Add(SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword));
}
if (property.IsSealed)
{
tokens.Add(SyntaxFactory.Token(SyntaxKind.SealedKeyword));
}
if (property.IsOverride)
{
tokens.Add(SyntaxFactory.Token(SyntaxKind.OverrideKeyword));
}
if (property.IsVirtual)
{
tokens.Add(SyntaxFactory.Token(SyntaxKind.VirtualKeyword));
}
if (property.IsAbstract)
{
tokens.Add(SyntaxFactory.Token(SyntaxKind.AbstractKeyword));
}
}
}
if (CodeGenerationPropertyInfo.GetIsUnsafe(property))
{
tokens.Add(SyntaxFactory.Token(SyntaxKind.UnsafeKeyword));
}
return(tokens.ToSyntaxTokenList());
}
public static ParameterListSyntax GenerateParameterList(
IEnumerable <IParameterSymbol> parameterDefinitions,
bool isExplicit,
CSharpCodeGenerationOptions options)
{
var parameters = GetParameters(parameterDefinitions, isExplicit, options);
return(SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList(parameters)));
}
internal static ConversionOperatorDeclarationSyntax GenerateConversionDeclaration(
IMethodSymbol method,
CSharpCodeGenerationOptions options,
CancellationToken cancellationToken)
{
var declaration = GenerateConversionDeclarationWorker(method, options);
return(AddFormatterAndCodeGeneratorAnnotationsTo(AddAnnotationsTo(method,
ConditionallyAddDocumentationCommentTo(declaration, method, options, cancellationToken))));
}
private static AccessorListSyntax GenerateAccessorList(
IEventSymbol @event, CodeGenerationDestination destination, CSharpCodeGenerationOptions options)
{
var accessors = new List <AccessorDeclarationSyntax?>
{
GenerateAccessorDeclaration(@event, @event.AddMethod, SyntaxKind.AddAccessorDeclaration, destination, options),
GenerateAccessorDeclaration(@event, @event.RemoveMethod, SyntaxKind.RemoveAccessorDeclaration, destination, options),
};
return(SyntaxFactory.AccessorList(accessors.WhereNotNull().ToSyntaxList()));
}
public static SyntaxNode UpdateCompilationUnitOrNamespaceDeclaration(
ICodeGenerationService service,
SyntaxNode declaration,
IList <ISymbol> newMembers,
CSharpCodeGenerationOptions options,
CancellationToken cancellationToken)
{
declaration = RemoveAllMembers(declaration);
declaration = service.AddMembers(declaration, newMembers, options, cancellationToken);
return(AddFormatterAndCodeGeneratorAnnotationsTo(declaration));
}
internal static TypeDeclarationSyntax AddOperatorTo(
TypeDeclarationSyntax destination,
IMethodSymbol method,
CSharpCodeGenerationOptions options,
IList <bool>?availableIndices,
CancellationToken cancellationToken)
{
var methodDeclaration = GenerateOperatorDeclaration(method, options, cancellationToken);
var members = Insert(destination.Members, methodDeclaration, options, availableIndices, after: LastOperator);
return(AddMembersTo(destination, members, cancellationToken));
}
public static BracketedParameterListSyntax GenerateBracketedParameterList(
IEnumerable <IParameterSymbol> parameterDefinitions,
bool isExplicit,
CSharpCodeGenerationOptions options)
{
// Bracketed parameter lists come from indexers. Those don't have type parameters, so we
// could never have a typeParameterMapping.
var parameters = GetParameters(parameterDefinitions, isExplicit, options);
return(SyntaxFactory.BracketedParameterList(
parameters: SyntaxFactory.SeparatedList(parameters)));
}
private static MemberDeclarationSyntax GenerateEventFieldDeclaration(
IEventSymbol @event, CodeGenerationDestination destination, CSharpCodeGenerationOptions options)
{
return(AddFormatterAndCodeGeneratorAnnotationsTo(
AddAnnotationsTo(@event,
SyntaxFactory.EventFieldDeclaration(
AttributeGenerator.GenerateAttributeLists(@event.GetAttributes(), options),
GenerateModifiers(@event, destination, options),
SyntaxFactory.VariableDeclaration(
@event.Type.GenerateTypeSyntax(),
SyntaxFactory.SingletonSeparatedList(SyntaxFactory.VariableDeclarator(@event.Name.ToIdentifierToken())))))));
}
private static MemberDeclarationSyntax GenerateEventDeclarationWorker(
IEventSymbol @event, CodeGenerationDestination destination, CSharpCodeGenerationOptions options)
{
var explicitInterfaceSpecifier = GenerateExplicitInterfaceSpecifier(@event.ExplicitInterfaceImplementations);
return(AddFormatterAndCodeGeneratorAnnotationsTo(SyntaxFactory.EventDeclaration(
attributeLists: AttributeGenerator.GenerateAttributeLists(@event.GetAttributes(), options),
modifiers: GenerateModifiers(@event, destination, options),
type: @event.Type.GenerateTypeSyntax(),
explicitInterfaceSpecifier: explicitInterfaceSpecifier,
identifier: @event.Name.ToIdentifierToken(),
accessorList: GenerateAccessorList(@event, destination, options))));
}
public static TypeDeclarationSyntax AddNamedTypeTo(
ICodeGenerationService service,
TypeDeclarationSyntax destination,
INamedTypeSymbol namedType,
CSharpCodeGenerationOptions options,
IList <bool>?availableIndices,
CancellationToken cancellationToken)
{
var declaration = GenerateNamedTypeDeclaration(service, namedType, GetDestination(destination), options, cancellationToken);
var members = Insert(destination.Members, declaration, options, availableIndices);
return(AddMembersTo(destination, members, cancellationToken));
}
private static AttributeListSyntax?TryGenerateAttributeDeclaration(
AttributeData attribute, SyntaxToken?target, CSharpCodeGenerationOptions options)
{
var attributeSyntax = TryGenerateAttribute(attribute, options);
return(attributeSyntax == null
? null
: SyntaxFactory.AttributeList(
target.HasValue
? SyntaxFactory.AttributeTargetSpecifier(target.Value)
: null,
SyntaxFactory.SingletonSeparatedList(attributeSyntax)));
}
private static AccessorDeclarationSyntax?GenerateAccessorDeclaration(
IEventSymbol @event,
IMethodSymbol?accessor,
SyntaxKind kind,
CodeGenerationDestination destination,
CSharpCodeGenerationOptions options)
{
var hasBody = options.Context.GenerateMethodBodies && HasAccessorBodies(@event, destination, accessor);
return(accessor == null
? null
: GenerateAccessorDeclaration(accessor, kind, hasBody));
}
private static SyntaxNode GetDeclarationSyntaxWithoutMembers(
INamespaceSymbol @namespace,
INamespaceSymbol innermostNamespace,
string name,
CodeGenerationDestination destination,
CSharpCodeGenerationOptions options)
{
var reusableSyntax = GetReuseableSyntaxNodeForSymbol <SyntaxNode>(@namespace, options);
return(reusableSyntax == null
? GenerateNamespaceDeclarationWorker(name, innermostNamespace, destination, options)
: RemoveAllMembers(reusableSyntax));
}
public static CompilationUnitSyntax AddNamedTypeTo(
ICodeGenerationService service,
CompilationUnitSyntax destination,
INamedTypeSymbol namedType,
CSharpCodeGenerationOptions options,
IList <bool>?availableIndices,
CancellationToken cancellationToken)
{
var declaration = GenerateNamedTypeDeclaration(service, namedType, CodeGenerationDestination.CompilationUnit, options, cancellationToken);
var members = Insert(destination.Members, declaration, options, availableIndices);
return(destination.WithMembers(members));
}
internal static BaseNamespaceDeclarationSyntax AddMethodTo(
BaseNamespaceDeclarationSyntax destination,
IMethodSymbol method,
CSharpCodeGenerationOptions options,
IList <bool>?availableIndices,
CancellationToken cancellationToken)
{
var declaration = GenerateMethodDeclaration(method, CodeGenerationDestination.Namespace, options, cancellationToken);
var members = Insert(destination.Members, declaration, options, availableIndices, after: LastMethod);
return(destination.WithMembers(members.ToSyntaxList()));
}
internal static TypeDeclarationSyntax AddMethodTo(
TypeDeclarationSyntax destination,
IMethodSymbol method,
CSharpCodeGenerationOptions options,
IList <bool>?availableIndices,
CancellationToken cancellationToken)
{
var methodDeclaration = GenerateMethodDeclaration(
method, GetDestination(destination), options, cancellationToken);
// Create a clone of the original type with the new method inserted.
var members = Insert(destination.Members, methodDeclaration, options, availableIndices, after: LastMethod);
return(AddMembersTo(destination, members, cancellationToken));
}
public static BaseNamespaceDeclarationSyntax AddNamedTypeTo(
ICodeGenerationService service,
BaseNamespaceDeclarationSyntax destination,
INamedTypeSymbol namedType,
CSharpCodeGenerationOptions options,
IList <bool>?availableIndices,
CancellationToken cancellationToken)
{
var declaration = GenerateNamedTypeDeclaration(service, namedType, CodeGenerationDestination.Namespace, options, cancellationToken);
var members = Insert(destination.Members, declaration, options, availableIndices);
return(ConditionallyAddFormattingAnnotationTo(
destination.WithMembers(members),
members));
}
private static AccessorListSyntax?GenerateAccessorList(
IPropertySymbol property, CodeGenerationDestination destination,
CSharpCodeGenerationOptions options)
{
var setAccessorKind = property.SetMethod?.IsInitOnly == true ? SyntaxKind.InitAccessorDeclaration : SyntaxKind.SetAccessorDeclaration;
var accessors = new[]
{
GenerateAccessorDeclaration(property, property.GetMethod, SyntaxKind.GetAccessorDeclaration, destination, options),
GenerateAccessorDeclaration(property, property.SetMethod, setAccessorKind, destination, options),
};
return(accessors[0] == null && accessors[1] == null
? null
: SyntaxFactory.AccessorList(accessors.WhereNotNull().ToSyntaxList()));
}
internal static ParameterSyntax GetParameter(IParameterSymbol p, CSharpCodeGenerationOptions options, bool isExplicit, bool isFirstParam, bool seenOptional)
{
var reusableSyntax = GetReuseableSyntaxNodeForSymbol <ParameterSyntax>(p, options);
if (reusableSyntax != null)
{
return(reusableSyntax);
}
return(SyntaxFactory.Parameter(p.Name.ToIdentifierToken())
.WithAttributeLists(GenerateAttributes(p, isExplicit, options))
.WithModifiers(GenerateModifiers(p, isFirstParam))
.WithType(p.Type.GenerateTypeSyntax())
.WithDefault(GenerateEqualsValueClause(p, isExplicit, seenOptional)));
}
internal static DestructorDeclarationSyntax GenerateDestructorDeclaration(
IMethodSymbol destructor, CSharpCodeGenerationOptions options, CancellationToken cancellationToken)
{
var reusableSyntax = GetReuseableSyntaxNodeForSymbol <DestructorDeclarationSyntax>(destructor, options);
if (reusableSyntax != null)
{
return(reusableSyntax);
}
var hasNoBody = !options.Context.GenerateMethodBodies;
var declaration = SyntaxFactory.DestructorDeclaration(
attributeLists: AttributeGenerator.GenerateAttributeLists(destructor.GetAttributes(), options),
modifiers: default,
internal static TypeDeclarationSyntax AddConstructorTo(
TypeDeclarationSyntax destination,
IMethodSymbol constructor,
CSharpCodeGenerationOptions options,
IList <bool>?availableIndices,
CancellationToken cancellationToken)
{
var constructorDeclaration = GenerateConstructorDeclaration(constructor, options, cancellationToken);
// Generate after the last constructor, or after the last field, or at the start of the
// type.
var members = Insert(destination.Members, constructorDeclaration, options,
availableIndices, after: LastConstructorOrField, before: FirstMember);
return(AddMembersTo(destination, members, cancellationToken));
}
