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 ConversionOperatorDeclarationSyntax GenerateConversionDeclarationWorker( IMethodSymbol method, CodeGenerationDestination destination, Workspace workspace, CodeGenerationOptions options, ParseOptions parseOptions) { 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); var declaration = 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()); declaration = UseExpressionBodyIfDesired(workspace, declaration, parseOptions); return(declaration); }
private static MemberDeclarationSyntax GenerateEventDeclarationWorker( IEventSymbol @event, CodeGenerationDestination destination, CodeGenerationOptions 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(),
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 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), explicitInterfaceSpecifier: explicitInterfaceSpecifier, parameterList: ParameterGenerator.GenerateBracketedParameterList(property.Parameters, explicitInterfaceSpecifier != null, options), type: property.GenerateTypeSyntax(), accessorList: GenerateAccessorList(property, destination, workspace, options, parseOptions)); declaration = UseExpressionBodyIfDesired(workspace, declaration, parseOptions); return(AddFormatterAndCodeGeneratorAnnotationsTo( AddAnnotationsTo(property, 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: property.GenerateTypeSyntax(), explicitInterfaceSpecifier: explicitInterfaceSpecifier, identifier: property.Name.ToIdentifierToken(), accessorList: accessorList, expressionBody: 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); }
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), parameterList: ParameterGenerator.GenerateParameterList(constructor.Parameters, isExplicit: false, options: options), initializer: GenerateConstructorInitializer(constructor), body: hasNoBody ? null : GenerateBlock(constructor), expressionBody: null, eosToken: hasNoBody ? SyntaxFactory.Token(SyntaxKind.SemicolonToken) : default);
public static FieldDeclarationSyntax GenerateFieldDeclaration( IFieldSymbol field, CodeGenerationDestination destination, CodeGenerationOptions options) { var reusableSyntax = GetReuseableSyntaxNodeForSymbol <VariableDeclarationSyntax>(field, options); if (reusableSyntax != null) { // TODO } var initializerNode = CodeGenerationFieldInfo.GetInitializer(field) as ExpressionSyntax; var initializer = initializerNode != null ? SyntaxFactory.EqualsValueClause(initializerNode) : GenerateEqualsValue(field); var fieldDeclaration = SyntaxFactory.FieldDeclaration( AttributeGenerator.GenerateAttributeLists(field.GetAttributes(), options), GenerateModifiers(field, options), SyntaxFactory.VariableDeclaration(SyntaxFactory.Token(SyntaxKind.VarKeyword), field.Name.ToIdentifierToken(), field.Type.GenerateTypeSyntax(), initializer)); return(AddFormatterAndCodeGeneratorAnnotationsTo( ConditionallyAddDocumentationCommentTo(fieldDeclaration, field, options))); }
private static SyntaxList <AttributeSyntax> GenerateAttributeDeclarations( INamedTypeSymbol namedType, CodeGenerationOptions options) { return(AttributeGenerator.GenerateAttributeLists(namedType.GetAttributes(), options)); }