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()));
}
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()));
}
private static MethodDeclarationSyntax GenerateMethodDeclarationWorker(
IMethodSymbol method, CodeGenerationDestination destination,
Workspace workspace, CodeGenerationOptions options, ParseOptions parseOptions)
{
var hasNoBody = !options.GenerateMethodBodies ||
destination == CodeGenerationDestination.InterfaceType ||
method.IsAbstract;
var explicitInterfaceSpecifier = GenerateExplicitInterfaceSpecifier(method.ExplicitInterfaceImplementations);
var returnType = method.ReturnsByRef
? method.ReturnType.GenerateRefTypeSyntax()
: method.ReturnType.GenerateTypeSyntax();
var methodDeclaration = SyntaxFactory.MethodDeclaration(
attributeLists: GenerateAttributes(method, options, explicitInterfaceSpecifier != null),
modifiers: GenerateModifiers(method, destination, options),
returnType: returnType,
explicitInterfaceSpecifier: explicitInterfaceSpecifier,
identifier: method.Name.ToIdentifierToken(),
typeParameterList: GenerateTypeParameterList(method, options),
parameterList: ParameterGenerator.GenerateParameterList(method.Parameters, explicitInterfaceSpecifier != null, options),
constraintClauses: GenerateConstraintClauses(method),
body: hasNoBody ? null : StatementGenerator.GenerateBlock(method),
expressionBody: default(ArrowExpressionClauseSyntax),
semicolonToken: hasNoBody ? SyntaxFactory.Token(SyntaxKind.SemicolonToken) : new SyntaxToken());
methodDeclaration = UseExpressionBodyIfDesired(workspace, methodDeclaration, parseOptions);
return(AddCleanupAnnotationsTo(methodDeclaration));
}
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 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);
}
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 override SyntaxNode CreateLambdaExpression(IList <IParameterSymbol> parameters, SyntaxNode body)
{
if (parameters.Count == 1 && parameters[0].Type == null)
{
return(SyntaxFactory.SimpleLambdaExpression(
SyntaxFactory.Parameter(parameters[0].Name.ToIdentifierToken()),
(CSharpSyntaxNode)body));
}
else
{
return(SyntaxFactory.ParenthesizedLambdaExpression(
ParameterGenerator.GenerateParameterList(parameters, isExplicit: false, options: CodeGenerationOptions.Default),
(CSharpSyntaxNode)body));
}
}
private static DelegateDeclarationSyntax GenerateDelegateDeclaration(
INamedTypeSymbol namedType,
CodeGenerationDestination destination,
CodeGenerationOptions options)
{
var invokeMethod = namedType.DelegateInvokeMethod;
return(SyntaxFactory.DelegateDeclaration(
GenerateAttributeDeclarations(namedType, options),
GenerateModifiers(namedType, destination, options),
invokeMethod.ReturnType.GenerateTypeSyntax(),
namedType.Name.ToIdentifierToken(),
TypeParameterGenerator.GenerateTypeParameterList(namedType.TypeParameters, options),
ParameterGenerator.GenerateParameterList(invokeMethod.Parameters, isExplicit: false, options: options),
namedType.TypeParameters.GenerateConstraintClauses()));
}
private static RecordDeclarationSyntax GenerateRecordMembers(
ICodeGenerationService service,
CodeGenerationOptions options,
RecordDeclarationSyntax recordDeclaration,
ImmutableArray <ISymbol> members,
CancellationToken cancellationToken)
{
// 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, options);
recordDeclaration = recordDeclaration.WithParameterList(parameterList);
// remove the primary constructor from the list of members to generate.
members = members.Remove(primaryConstructor);
// remove any properties that were created by the primary constructor
members = members.WhereAsArray(m => m is not IPropertySymbol property || !primaryConstructor.Parameters.Any(p => p.Name == property.Name));
}
// remove any implicit overrides to generate.
members = members.WhereAsArray(m => !m.IsImplicitlyDeclared);
// If there are no members, just make a simple record with no body
if (members.Length == 0)
{
recordDeclaration = recordDeclaration.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken));
}
else
{
// Otherwise, give the record a body.
recordDeclaration = recordDeclaration.WithOpenBraceToken(SyntaxFactory.Token(SyntaxKind.OpenBraceToken))
.WithCloseBraceToken(SyntaxFactory.Token(SyntaxKind.CloseBraceToken));
}
if (options.GenerateMembers)
{
recordDeclaration = service.AddMembers(recordDeclaration, members, options, cancellationToken);
}
return(recordDeclaration);
}
private static MethodDeclarationSyntax GenerateMethodDeclarationWorker(
IMethodSymbol method, CodeGenerationDestination destination,
Workspace workspace, CodeGenerationOptions options, ParseOptions parseOptions)
{
var hasNoBody = !options.GenerateMethodBodies ||
destination == CodeGenerationDestination.InterfaceType ||
method.IsAbstract;
var explicitInterfaceSpecifier = GenerateExplicitInterfaceSpecifier(method.ExplicitInterfaceImplementations);
var methodDeclaration = SyntaxFactory.MethodDeclaration(
attributeLists: GenerateAttributes(method, options, explicitInterfaceSpecifier != null),
modifiers: GenerateModifiers(method, destination, options),
returnType: method.GenerateReturnTypeSyntax(),
explicitInterfaceSpecifier: explicitInterfaceSpecifier,
identifier: method.Name.ToIdentifierToken(),
typeParameterList: GenerateTypeParameterList(method, options),
parameterList: ParameterGenerator.GenerateParameterList(method.Parameters, explicitInterfaceSpecifier != null, options),
constraintClauses: GenerateConstraintClauses(method),
body: hasNoBody ? null : StatementGenerator.GenerateBlock(method),
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);
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 MethodDeclarationSyntax GenerateMethodDeclarationWorker(
IMethodSymbol method, CodeGenerationDestination destination,
Workspace workspace, CodeGenerationOptions options, ParseOptions parseOptions)
{
// Don't rely on destination to decide if method body should be generated.
// Users of this service need to express their intention explicitly, either by
// setting `CodeGenerationOptions.GenerateMethodBodies` to true, or making
// `method` abstract. This would provide more flexibility.
var hasNoBody = !options.GenerateMethodBodies || method.IsAbstract;
var explicitInterfaceSpecifier = GenerateExplicitInterfaceSpecifier(method.ExplicitInterfaceImplementations);
var methodDeclaration = SyntaxFactory.MethodDeclaration(
attributeLists: GenerateAttributes(method, options, explicitInterfaceSpecifier != null),
modifiers: GenerateModifiers(method, destination, workspace, options, localFunction: false),
returnType: method.GenerateReturnTypeSyntax(),
explicitInterfaceSpecifier: explicitInterfaceSpecifier,
identifier: method.Name.ToIdentifierToken(),
typeParameterList: GenerateTypeParameterList(method, options),
parameterList: ParameterGenerator.GenerateParameterList(method.Parameters, explicitInterfaceSpecifier != null, options),
constraintClauses: GenerateConstraintClauses(method),
body: hasNoBody ? null : StatementGenerator.GenerateBlock(method),
expressionBody: default,