private static DelegateDeclarationSyntax GenerateDelegateDeclaration( INamedTypeSymbol namedType, CodeGenerationDestination destination, CodeGenerationOptions options) { var invokeMethod = namedType.DelegateInvokeMethod; Contract.ThrowIfNull(invokeMethod); 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())); }
public override TDeclarationNode AddParameters <TDeclarationNode>( TDeclarationNode destinationMember, IEnumerable <IParameterSymbol> parameters, CodeGenerationOptions options, CancellationToken cancellationToken) { var memberDeclaration = destinationMember as MemberDeclarationSyntax; if (memberDeclaration == null) { return(destinationMember); } var currentParameterList = memberDeclaration.GetParameterList(); if (currentParameterList == null) { return(destinationMember); } var currentParamsCount = currentParameterList.Parameters.Count; var seenOptional = currentParamsCount > 0 && currentParameterList.Parameters[currentParamsCount - 1].Default != null; var isFirstParam = currentParamsCount == 0; var parameterNodesAndTokens = currentParameterList.Parameters.GetWithSeparators().ToList(); foreach (var parameter in parameters) { if (parameterNodesAndTokens.Count > 0 && parameterNodesAndTokens.Last().Kind() != SyntaxKind.CommaToken) { parameterNodesAndTokens.Add(SyntaxFactory.Token(SyntaxKind.CommaToken)); } var parameterSyntax = ParameterGenerator.GetParameter(parameter, options, isExplicit: false, isFirstParam: isFirstParam, seenOptional: seenOptional); parameterNodesAndTokens.Add(parameterSyntax); isFirstParam = false; seenOptional = seenOptional || parameterSyntax.Default != null; } var finalParameterList = currentParameterList.WithParameters(SyntaxFactory.SeparatedList <ParameterSyntax>(parameterNodesAndTokens)); var finalMember = memberDeclaration.WithParameterList(finalParameterList); return(Cast <TDeclarationNode>(finalMember)); }
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 MemberDeclarationSyntax GenerateIndexerDeclaration( IPropertySymbol property, CodeGenerationDestination destination, CSharpCodeGenerationContextInfo info) { var explicitInterfaceSpecifier = GenerateExplicitInterfaceSpecifier(property.ExplicitInterfaceImplementations); var declaration = SyntaxFactory.IndexerDeclaration( attributeLists: AttributeGenerator.GenerateAttributeLists(property.GetAttributes(), info), modifiers: GenerateModifiers(property, destination, info), type: GenerateTypeSyntax(property), explicitInterfaceSpecifier: explicitInterfaceSpecifier, parameterList: ParameterGenerator.GenerateBracketedParameterList(property.Parameters, explicitInterfaceSpecifier != null, info), accessorList: GenerateAccessorList(property, destination, info)); declaration = UseExpressionBodyIfDesired(info, declaration); return(AddFormatterAndCodeGeneratorAnnotationsTo( AddAnnotationsTo(property, declaration))); }
private static MethodDeclarationSyntax GenerateMethodDeclarationWorker( IMethodSymbol method, CodeGenerationDestination destination, CodeGenerationOptions options) { var hasNoBody = !options.GenerateMethodBodies || destination == CodeGenerationDestination.InterfaceType || method.IsAbstract; var explicitInterfaceSpecifier = GenerateExplicitInterfaceSpecifier(method.ExplicitInterfaceImplementations); return(AddCleanupAnnotationsTo(SyntaxFactory.MethodDeclaration( attributeLists: GenerateAttributes(method, options, explicitInterfaceSpecifier != null), modifiers: GenerateModifiers(method, destination, options), returnType: method.ReturnType.GenerateTypeSyntax(), 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), 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 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, CSharpCodeGenerationOptions options, CancellationToken cancellationToken) { var reusableSyntax = GetReuseableSyntaxNodeForSymbol <ConstructorDeclarationSyntax>(constructor, options); if (reusableSyntax != null) { return(reusableSyntax); } var hasNoBody = !options.Context.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);
private static MemberDeclarationSyntax GenerateIndexerDeclaration( IPropertySymbol property, CodeGenerationDestination destination, Workspace workspace, 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: GeneratePropertyType(property), explicitInterfaceSpecifier: explicitInterfaceSpecifier, parameterList: ParameterGenerator.GenerateBracketedParameterList(property.Parameters, explicitInterfaceSpecifier != null, options), accessorList: GenerateAccessorList(property, destination, workspace, options, parseOptions)); declaration = UseExpressionBodyIfDesired(workspace, declaration, parseOptions); return(AddFormatterAndCodeGeneratorAnnotationsTo( AddAnnotationsTo(property, declaration))); }
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,