internal static DestructorDeclarationSyntax GenerateDestructorDeclaration(
IMethodSymbol destructor, CodeGenerationDestination destination, CodeGenerationOptions options)
{
options = options ?? CodeGenerationOptions.Default;
var reusableSyntax = GetReuseableSyntaxNodeForSymbol <DestructorDeclarationSyntax>(destructor, options);
if (reusableSyntax != null)
{
return(reusableSyntax);
}
bool hasNoBody = !options.GenerateMethodBodies;
var declaration = SyntaxFactory.DestructorDeclaration(
attributeLists: AttributeGenerator.GenerateAttributeLists(destructor.GetAttributes(), options),
modifiers: default(SyntaxTokenList),
tildeToken: SyntaxFactory.Token(SyntaxKind.TildeToken),
identifier: CodeGenerationDestructorInfo.GetTypeName(destructor).ToIdentifierToken(),
parameterList: SyntaxFactory.ParameterList(),
body: hasNoBody ? null : GenerateBlock(destructor),
semicolonToken: hasNoBody ? SyntaxFactory.Token(SyntaxKind.SemicolonToken) : default(SyntaxToken));
return(AddCleanupAnnotationsTo(
ConditionallyAddDocumentationCommentTo(declaration, destructor, options)));
}
internal static ConstructorDeclarationSyntax GenerateConstructorDeclaration(
IMethodSymbol constructor,
Workspace workspace,
CodeGenerationOptions options,
ParseOptions parseOptions)
{
options ??= CodeGenerationOptions.Default;
var reusableSyntax = GetReuseableSyntaxNodeForSymbol <ConstructorDeclarationSyntax>(constructor, options);
if (reusableSyntax != null)
{
return(reusableSyntax);
}
var hasNoBody = !options.GenerateMethodBodies;
var declaration = SyntaxFactory.ConstructorDeclaration(
attributeLists: AttributeGenerator.GenerateAttributeLists(constructor.GetAttributes(), options),
modifiers: GenerateModifiers(constructor, options),
identifier: CodeGenerationConstructorInfo.GetTypeName(constructor).ToIdentifierToken(),
parameterList: ParameterGenerator.GenerateParameterList(constructor.Parameters, isExplicit: false, options: options),
initializer: GenerateConstructorInitializer(constructor),
body: hasNoBody ? null : GenerateBlock(constructor),
semicolonToken: hasNoBody ? SyntaxFactory.Token(SyntaxKind.SemicolonToken) : default);
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)));
}
internal static ConstructorDeclarationSyntax GenerateConstructorDeclaration(
IMethodSymbol constructor, CodeGenerationDestination destination,
Workspace workspace, CodeGenerationOptions options, ParseOptions parseOptions)
{
options = options ?? CodeGenerationOptions.Default;
var reusableSyntax = GetReuseableSyntaxNodeForSymbol <ConstructorDeclarationSyntax>(constructor, options);
if (reusableSyntax != null)
{
return(reusableSyntax);
}
var hasNoBody = !options.GenerateMethodBodies;
var declaration = SyntaxFactory.ConstructorDeclaration(
attributeLists: AttributeGenerator.GenerateAttributeLists(constructor.GetAttributes(), options),
modifiers: GenerateModifiers(constructor, options),
identifier: CodeGenerationConstructorInfo.GetTypeName(constructor).ToIdentifierToken(),
parameterList: ParameterGenerator.GenerateParameterList(constructor.Parameters, isExplicit: false, options: options),
initializer: GenerateConstructorInitializer(constructor),
body: hasNoBody ? null : GenerateBlock(constructor),
semicolonToken: hasNoBody ? SyntaxFactory.Token(SyntaxKind.SemicolonToken) : default(SyntaxToken));
declaration = UseExpressionBodyIfDesired(workspace, declaration, parseOptions);
return(AddCleanupAnnotationsTo(
ConditionallyAddDocumentationCommentTo(declaration, constructor, options)));
}
private static ConversionOperatorDeclarationSyntax GenerateConversionDeclarationWorker(
IMethodSymbol method,
CodeGenerationDestination destination,
CodeGenerationOptions options)
{
var hasNoBody = !options.GenerateMethodBodies || method.IsExtern;
var reusableSyntax = GetReuseableSyntaxNodeForSymbol <ConversionOperatorDeclarationSyntax>(method, options);
if (reusableSyntax != null)
{
return(reusableSyntax);
}
var operatorToken = SyntaxFactory.Token(SyntaxFacts.GetOperatorKind(method.MetadataName));
var keyword = method.MetadataName == WellKnownMemberNames.ImplicitConversionName
? SyntaxFactory.Token(SyntaxKind.ImplicitKeyword)
: SyntaxFactory.Token(SyntaxKind.ExplicitKeyword);
return(SyntaxFactory.ConversionOperatorDeclaration(
attributeLists: AttributeGenerator.GenerateAttributeLists(method.GetAttributes(), options),
modifiers: GenerateModifiers(method),
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()));
}
internal static DestructorDeclarationSyntax GenerateDestructorDeclaration(
IMethodSymbol destructor,
CodeGenerationOptions options
)
{
options ??= CodeGenerationOptions.Default;
var reusableSyntax = GetReuseableSyntaxNodeForSymbol <DestructorDeclarationSyntax>(
destructor,
options
);
if (reusableSyntax != null)
{
return(reusableSyntax);
}
var hasNoBody = !options.GenerateMethodBodies;
var declaration = SyntaxFactory.DestructorDeclaration(
attributeLists: AttributeGenerator.GenerateAttributeLists(
destructor.GetAttributes(),
options
),
modifiers: default,
private static MemberDeclarationSyntax GenerateIndexerDeclaration(
IPropertySymbol property,
CodeGenerationDestination destination,
CodeGenerationOptions options,
ParseOptions parseOptions
)
{
var explicitInterfaceSpecifier = GenerateExplicitInterfaceSpecifier(
property.ExplicitInterfaceImplementations
);
var declaration = SyntaxFactory.IndexerDeclaration(
attributeLists: AttributeGenerator.GenerateAttributeLists(
property.GetAttributes(),
options
),
modifiers: GenerateModifiers(property, destination, options),
type: GenerateTypeSyntax(property),
explicitInterfaceSpecifier: explicitInterfaceSpecifier,
parameterList: ParameterGenerator.GenerateBracketedParameterList(
property.Parameters,
explicitInterfaceSpecifier != null,
options
),
accessorList: GenerateAccessorList(property, destination, options, parseOptions)
);
declaration = UseExpressionBodyIfDesired(options, declaration, parseOptions);
return(AddFormatterAndCodeGeneratorAnnotationsTo(
AddAnnotationsTo(property, declaration)
));
}
private static MemberDeclarationSyntax GeneratePropertyDeclaration(
IPropertySymbol property, CodeGenerationDestination destination,
Workspace workspace, CodeGenerationOptions options, ParseOptions parseOptions)
{
var initializer = CodeGenerationPropertyInfo.GetInitializer(property) is ExpressionSyntax initializerNode
? SyntaxFactory.EqualsValueClause(initializerNode)
: null;
var explicitInterfaceSpecifier = GenerateExplicitInterfaceSpecifier(property.ExplicitInterfaceImplementations);
var accessorList = GenerateAccessorList(property, destination, workspace, options, parseOptions);
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(
workspace, propertyDeclaration, parseOptions);
return(AddFormatterAndCodeGeneratorAnnotationsTo(
AddAnnotationsTo(property, propertyDeclaration)));
}
private static OperatorDeclarationSyntax GenerateOperatorDeclarationWorker(
IMethodSymbol method,
CodeGenerationDestination destination,
CodeGenerationOptions options)
{
var hasNoBody = !options.GenerateMethodBodies || method.IsExtern;
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);
return(SyntaxFactory.OperatorDeclaration(
attributeLists: AttributeGenerator.GenerateAttributeLists(method.GetAttributes(), options),
modifiers: GenerateModifiers(method),
returnType: method.ReturnType.GenerateTypeSyntax(),
operatorKeyword: SyntaxFactory.Token(SyntaxKind.OperatorKeyword),
operatorToken: operatorToken,
parameterList: ParameterGenerator.GenerateParameterList(method.Parameters, isExplicit: false, options: options),
body: hasNoBody ? null : StatementGenerator.GenerateBlock(method),
semicolonToken: hasNoBody ? SyntaxFactory.Token(SyntaxKind.SemicolonToken) : new SyntaxToken()));
}
private static SyntaxList <AttributeListSyntax> GenerateAttributeDeclarations(
INamedTypeSymbol namedType,
CodeGenerationOptions options
)
{
return(AttributeGenerator.GenerateAttributeLists(namedType.GetAttributes(), options));
}
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);
}
public static FieldDeclarationSyntax GenerateFieldDeclaration(
IFieldSymbol field, CodeGenerationOptions options)
{
var reusableSyntax = GetReuseableSyntaxNodeForSymbol <VariableDeclaratorSyntax>(field, options);
if (reusableSyntax != null)
{
if (reusableSyntax.Parent is VariableDeclarationSyntax variableDeclaration)
{
var newVariableDeclaratorsList = new SeparatedSyntaxList <VariableDeclaratorSyntax>().Add(reusableSyntax);
var newVariableDeclaration = variableDeclaration.WithVariables(newVariableDeclaratorsList);
if (variableDeclaration.Parent is FieldDeclarationSyntax fieldDecl)
{
return(fieldDecl.WithDeclaration(newVariableDeclaration));
}
}
}
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)));
}
public override TDeclarationNode AddAttributes <TDeclarationNode>(
TDeclarationNode destination,
IEnumerable <AttributeData> attributes,
SyntaxToken?target,
CodeGenerationOptions options,
CancellationToken cancellationToken)
{
if (target.HasValue && !target.Value.IsValidAttributeTarget())
{
throw new ArgumentException("target");
}
var attributeSyntaxList = AttributeGenerator.GenerateAttributeLists(attributes.ToImmutableArray(), options, target).ToArray();
// Handle all members including types.
var member = destination as MemberDeclarationSyntax;
if (member != null)
{
return(Cast <TDeclarationNode>(member.AddAttributeLists(attributeSyntaxList)));
}
// Handle accessors
var accessor = destination as AccessorDeclarationSyntax;
if (accessor != null)
{
return(Cast <TDeclarationNode>(accessor.AddAttributeLists(attributeSyntaxList)));
}
// Handle global attributes
var compilationUnit = destination as CompilationUnitSyntax;
if (compilationUnit != null)
{
return(Cast <TDeclarationNode>(compilationUnit.AddAttributeLists(attributeSyntaxList)));
}
// Handle parameters
var parameter = destination as ParameterSyntax;
if (parameter != null)
{
return(Cast <TDeclarationNode>(parameter.AddAttributeLists(attributeSyntaxList)));
}
var typeParameter = destination as TypeParameterSyntax;
if (typeParameter != null)
{
return(Cast <TDeclarationNode>(typeParameter.AddAttributeLists(attributeSyntaxList)));
}
return(destination);
}
private static TypeParameterSyntax GenerateTypeParameter(ITypeParameterSymbol symbol, CodeGenerationOptions options)
{
var varianceKeyword =
symbol.Variance == VarianceKind.In ? SyntaxFactory.Token(SyntaxKind.InKeyword) :
symbol.Variance == VarianceKind.Out ? SyntaxFactory.Token(SyntaxKind.OutKeyword) : default;
return(SyntaxFactory.TypeParameter(
AttributeGenerator.GenerateAttributeLists(symbol.GetAttributes(), options),
varianceKeyword,
symbol.Name.ToIdentifierToken()));
}
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())))))));
}
private static MemberDeclarationSyntax GenerateEventFieldDeclaration(
IEventSymbol @event, CodeGenerationDestination destination, CodeGenerationOptions options)
{
return(AddCleanupAnnotationsTo(
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 SyntaxList <AttributeListSyntax> GenerateAttributes(
IMethodSymbol method, CodeGenerationOptions options, bool isExplicit)
{
var attributes = new List <AttributeListSyntax>();
if (!isExplicit)
{
attributes.AddRange(AttributeGenerator.GenerateAttributeLists(method.GetAttributes(), options));
attributes.AddRange(AttributeGenerator.GenerateAttributeLists(method.GetReturnTypeAttributes(), options, SyntaxFactory.Token(SyntaxKind.ReturnKeyword)));
}
return(attributes.ToSyntaxList());
}
private static MemberDeclarationSyntax GenerateEventDeclarationWorker(
IEventSymbol @event, CodeGenerationDestination destination, CodeGenerationOptions options)
{
var explicitInterfaceSpecifier = GenerateExplicitInterfaceSpecifier(@event.ExplicitInterfaceImplementations);
return(AddCleanupAnnotationsTo(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 MemberDeclarationSyntax GeneratePropertyDeclaration(
IPropertySymbol property, CodeGenerationDestination destination, CodeGenerationOptions options)
{
var explicitInterfaceSpecifier = GenerateExplicitInterfaceSpecifier(property.ExplicitInterfaceImplementations);
return(AddCleanupAnnotationsTo(
AddAnnotationsTo(property, SyntaxFactory.PropertyDeclaration(
attributeLists: AttributeGenerator.GenerateAttributeLists(property.GetAttributes(), options),
modifiers: GenerateModifiers(property, destination, options),
type: property.Type.GenerateTypeSyntax(),
explicitInterfaceSpecifier: explicitInterfaceSpecifier,
identifier: property.Name.ToIdentifierToken(),
accessorList: GenerateAccessorList(property, destination, options)))));
}
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,
private static MemberDeclarationSyntax GenerateIndexerDeclaration(
IPropertySymbol property,
CodeGenerationDestination destination,
CodeGenerationOptions options)
{
var explicitInterfaceSpecifier = GenerateExplicitInterfaceSpecifier(property.ExplicitInterfaceImplementations);
return(AddCleanupAnnotationsTo(
AddAnnotationsTo(property, SyntaxFactory.IndexerDeclaration(
attributeLists: AttributeGenerator.GenerateAttributeLists(property.GetAttributes(), options),
modifiers: GenerateModifiers(property, destination, options),
type: property.Type.GenerateTypeSyntax(),
explicitInterfaceSpecifier: explicitInterfaceSpecifier,
parameterList: ParameterGenerator.GenerateBracketedParameterList(property.Parameters, explicitInterfaceSpecifier != null, options),
accessorList: GenerateAccessorList(property, destination, options)))));
}
private static SyntaxList <AttributeListSyntax> GenerateAttributes(
IParameterSymbol parameter, bool isExplicit, CodeGenerationOptions options)
{
if (isExplicit)
{
return(default(SyntaxList <AttributeListSyntax>));
}
var attributes = parameter.GetAttributes();
if (attributes.Length == 0)
{
return(default(SyntaxList <AttributeListSyntax>));
}
return(AttributeGenerator.GenerateAttributeLists(attributes, options));
}
public static MemberDeclarationSyntax GeneratePropertyDeclaration(
IPropertySymbol property, CodeGenerationDestination destination, CodeGenerationOptions options)
{
var initializerNode = CodeGenerationPropertyInfo.GetInitializer(property) as ExpressionSyntax;
var initializer = initializerNode != null
? SyntaxFactory.EqualsValueClause(initializerNode)
: default(EqualsValueClauseSyntax);
var explicitInterfaceSpecifier = GenerateExplicitInterfaceSpecifier(property.ExplicitInterfaceImplementations);
return(AddCleanupAnnotationsTo(
AddAnnotationsTo(property, SyntaxFactory.PropertyDeclaration(
attributeLists: AttributeGenerator.GenerateAttributeLists(property.GetAttributes(), options),
modifiers: GenerateModifiers(property, destination, options),
type: property.Type.GenerateTypeSyntax(),
explicitInterfaceSpecifier: explicitInterfaceSpecifier,
identifier: property.Name.ToIdentifierToken(),
accessorList: GenerateAccessorList(property, destination, options),
initializer: initializer))));
}
private static ConversionOperatorDeclarationSyntax GenerateConversionDeclarationWorker(
IMethodSymbol method,
CodeGenerationDestination destination,
CSharpCodeGenerationContextInfo info)
{
var hasNoBody = !info.Context.GenerateMethodBodies || method.IsExtern;
var reusableSyntax = GetReuseableSyntaxNodeForSymbol <ConversionOperatorDeclarationSyntax>(method, info);
if (reusableSyntax != null)
{
return(reusableSyntax);
}
var keyword = method.MetadataName == WellKnownMemberNames.ImplicitConversionName
? SyntaxFactory.Token(SyntaxKind.ImplicitKeyword)
: SyntaxFactory.Token(SyntaxKind.ExplicitKeyword);
var checkedToken = SyntaxFacts.IsCheckedOperator(method.MetadataName)
? SyntaxFactory.Token(SyntaxKind.CheckedKeyword)
: default;
var declaration = SyntaxFactory.ConversionOperatorDeclaration(
attributeLists: AttributeGenerator.GenerateAttributeLists(method.GetAttributes(), info),
modifiers: GenerateModifiers(destination),
implicitOrExplicitKeyword: keyword,
explicitInterfaceSpecifier: null,
operatorKeyword: SyntaxFactory.Token(SyntaxKind.OperatorKeyword),
checkedKeyword: checkedToken,
type: method.ReturnType.GenerateTypeSyntax(),
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());
declaration = UseExpressionBodyIfDesired(info, declaration);
return(declaration);
}
private static MemberDeclarationSyntax GeneratePropertyDeclaration(
IPropertySymbol property, CodeGenerationDestination destination,
Workspace workspace, CodeGenerationOptions options, ParseOptions parseOptions)
{
var initializerNode = CodeGenerationPropertyInfo.GetInitializer(property) as ExpressionSyntax;
var initializer = initializerNode != null
? SyntaxFactory.EqualsValueClause(initializerNode)
: default;
var explicitInterfaceSpecifier = GenerateExplicitInterfaceSpecifier(property.ExplicitInterfaceImplementations);
var accessorList = GenerateAccessorList(property, destination, workspace, options, parseOptions);
var propertyDeclaration = SyntaxFactory.PropertyDeclaration(
attributeLists: AttributeGenerator.GenerateAttributeLists(property.GetAttributes(), options),
modifiers: GenerateModifiers(property, destination, options),
type: GeneratePropertyType(property),
explicitInterfaceSpecifier: explicitInterfaceSpecifier,
identifier: property.Name.ToIdentifierToken(),
accessorList: accessorList,
expressionBody: default,
internal static ConstructorDeclarationSyntax GenerateConstructorDeclaration(
IMethodSymbol constructor,
CSharpCodeGenerationContextInfo info,
CancellationToken cancellationToken)
{
var reusableSyntax = GetReuseableSyntaxNodeForSymbol <ConstructorDeclarationSyntax>(constructor, info);
if (reusableSyntax != null)
{
return(reusableSyntax);
}
var hasNoBody = !info.Context.GenerateMethodBodies;
var declaration = SyntaxFactory.ConstructorDeclaration(
attributeLists: AttributeGenerator.GenerateAttributeLists(constructor.GetAttributes(), info),
modifiers: GenerateModifiers(constructor, info),
identifier: CodeGenerationConstructorInfo.GetTypeName(constructor).ToIdentifierToken(),
parameterList: ParameterGenerator.GenerateParameterList(constructor.Parameters, isExplicit: false, info: info),
initializer: GenerateConstructorInitializer(constructor),
body: hasNoBody ? null : GenerateBlock(constructor),
semicolonToken: hasNoBody ? SyntaxFactory.Token(SyntaxKind.SemicolonToken) : default);
public override TDeclarationNode AddAttributes <TDeclarationNode>(
TDeclarationNode destination,
IEnumerable <AttributeData> attributes,
SyntaxToken?target,
CodeGenerationOptions options,
CancellationToken cancellationToken)
{
if (target.HasValue && !target.Value.IsValidAttributeTarget())
{
throw new ArgumentException("target");
}
var attributeSyntaxList = AttributeGenerator.GenerateAttributeLists(attributes.ToImmutableArray(), options, target).ToArray();
switch (destination)
{
case MemberDeclarationSyntax member:
// Handle all members including types.
return(Cast <TDeclarationNode>(member.AddAttributeLists(attributeSyntaxList)));
case AccessorDeclarationSyntax accessor:
// Handle accessors
return(Cast <TDeclarationNode>(accessor.AddAttributeLists(attributeSyntaxList)));
case CompilationUnitSyntax compilationUnit:
// Handle global attributes
return(Cast <TDeclarationNode>(compilationUnit.AddAttributeLists(attributeSyntaxList)));
case ParameterSyntax parameter:
// Handle parameters
return(Cast <TDeclarationNode>(parameter.AddAttributeLists(attributeSyntaxList)));
case TypeParameterSyntax typeParameter:
return(Cast <TDeclarationNode>(typeParameter.AddAttributeLists(attributeSyntaxList)));
}
return(destination);
}
public override TDeclarationNode AddAttributes <TDeclarationNode>(
TDeclarationNode destination,
IEnumerable <AttributeData> attributes,
SyntaxToken?target,
CodeGenerationOptions options,
CancellationToken cancellationToken)
{
if (target.HasValue && !target.Value.IsValidAttributeTarget())
{
throw new ArgumentException("target");
}
var attributeSyntaxList = AttributeGenerator.GenerateAttributeLists(attributes.ToImmutableArray(), options, target).ToArray();
return(destination switch
{
MemberDeclarationSyntax member => Cast <TDeclarationNode>(member.AddAttributeLists(attributeSyntaxList)),
AccessorDeclarationSyntax accessor => Cast <TDeclarationNode>(accessor.AddAttributeLists(attributeSyntaxList)),
CompilationUnitSyntax compilationUnit => Cast <TDeclarationNode>(compilationUnit.AddAttributeLists(attributeSyntaxList)),
ParameterSyntax parameter => Cast <TDeclarationNode>(parameter.AddAttributeLists(attributeSyntaxList)),
TypeParameterSyntax typeParameter => Cast <TDeclarationNode>(typeParameter.AddAttributeLists(attributeSyntaxList)),
_ => destination,
});
