public override SyntaxNode CreateMethodDeclaration( IMethodSymbol method, CodeGenerationDestination destination, CodeGenerationOptions options) { // Synthesized methods for properties/events are not things we actually generate // declarations for. if (method.AssociatedSymbol is IEventSymbol) { return(null); } // we will ignore the method if the associated property can be generated. if (method.AssociatedSymbol is IPropertySymbol property) { if (PropertyGenerator.CanBeGenerated(property)) { return(null); } } if (method.IsConstructor()) { return(ConstructorGenerator.GenerateConstructorDeclaration( method, destination, Workspace, options, options.ParseOptions)); } else if (method.IsDestructor()) { return(DestructorGenerator.GenerateDestructorDeclaration(method, destination, options)); } else if (method.IsUserDefinedOperator()) { return(OperatorGenerator.GenerateOperatorDeclaration( method, destination, Workspace, options, options.ParseOptions)); } else if (method.IsConversion()) { return(ConversionGenerator.GenerateConversionDeclaration( method, destination, Workspace, options, options.ParseOptions)); } else { return(MethodGenerator.GenerateMethodDeclaration( method, destination, Workspace, options, options.ParseOptions)); } }
public override SyntaxNode CreatePropertyDeclaration( IPropertySymbol property, CodeGenerationDestination destination, CodeGenerationOptions options) { return(PropertyGenerator.GeneratePropertyOrIndexer( property, destination, Workspace, options, options.ParseOptions)); }
protected override TDeclarationNode AddMethod <TDeclarationNode>(TDeclarationNode destination, IMethodSymbol method, CodeGenerationOptions options, IList <bool> availableIndices) { CheckDeclarationNode <TypeDeclarationSyntax, CompilationUnitSyntax, NamespaceDeclarationSyntax>(destination); // Synthesized methods for properties/events are not things we actually generate // declarations for. if (method.AssociatedSymbol is IEventSymbol) { return(destination); } // we will ignore the method if the associated property can be generated. if (method.AssociatedSymbol is IPropertySymbol property) { if (PropertyGenerator.CanBeGenerated(property)) { return(destination); } } if (destination is TypeDeclarationSyntax typeDeclaration) { if (method.IsConstructor()) { return(Cast <TDeclarationNode>(ConstructorGenerator.AddConstructorTo( typeDeclaration, method, Workspace, options, availableIndices))); } if (method.IsDestructor()) { return(Cast <TDeclarationNode>(DestructorGenerator.AddDestructorTo(typeDeclaration, method, options, availableIndices))); } if (method.MethodKind == MethodKind.Conversion) { return(Cast <TDeclarationNode>(ConversionGenerator.AddConversionTo( typeDeclaration, method, Workspace, options, availableIndices))); } if (method.MethodKind == MethodKind.UserDefinedOperator) { return(Cast <TDeclarationNode>(OperatorGenerator.AddOperatorTo( typeDeclaration, method, Workspace, options, availableIndices))); } return(Cast <TDeclarationNode>(MethodGenerator.AddMethodTo( typeDeclaration, method, Workspace, options, availableIndices))); } if (method.IsConstructor() || method.IsDestructor()) { return(destination); } if (destination is CompilationUnitSyntax compilationUnit) { return(Cast <TDeclarationNode>( MethodGenerator.AddMethodTo(compilationUnit, method, Workspace, options, availableIndices))); } var ns = Cast <NamespaceDeclarationSyntax>(destination); return(Cast <TDeclarationNode>( MethodGenerator.AddMethodTo(ns, method, Workspace, options, availableIndices))); }
public static MemberDeclarationSyntax GenerateNamedTypeDeclaration( ICodeGenerationService service, INamedTypeSymbol namedType, CodeGenerationDestination destination, CodeGenerationOptions options, CancellationToken cancellationToken) { options ??= CodeGenerationOptions.Default; var declaration = GetDeclarationSyntaxWithoutMembers(namedType, destination, options); if (namedType.IsComImport) { // If we're generating a ComImport type, then do not attempt to do any // reordering of members. options = options.With(autoInsertionLocation: false, sortMembers: false); } // If we are generating members then make sure to exclude properties that cannot be generated. // Reason: Calling AddProperty on a propertysymbol that can't be generated (like one with params) causes // the getter and setter to get generated instead. Since the list of members is going to include // the method symbols for the getter and setter, we don't want to generate them twice. declaration = options.GenerateMembers && namedType.TypeKind != TypeKind.Delegate ? service.AddMembers(declaration, GetMembers(namedType).Where(s => s.Kind != SymbolKind.Property || PropertyGenerator.CanBeGenerated((IPropertySymbol)s)), options, cancellationToken) : declaration; return(AddFormatterAndCodeGeneratorAnnotationsTo(ConditionallyAddDocumentationCommentTo(declaration, namedType, options, cancellationToken))); }
protected override TDeclarationNode AddMethod <TDeclarationNode>(TDeclarationNode destination, IMethodSymbol method, CodeGenerationOptions options, IList <bool> availableIndices) { // https://github.com/dotnet/roslyn/issues/44425: Add handling for top level statements if (destination is GlobalStatementSyntax) { return(destination); } CheckDeclarationNode <TypeDeclarationSyntax, CompilationUnitSyntax, BaseNamespaceDeclarationSyntax>(destination); options = options.With(options: options.Options ?? Workspace.Options); // Synthesized methods for properties/events are not things we actually generate // declarations for. if (method.AssociatedSymbol is IEventSymbol) { return(destination); } // we will ignore the method if the associated property can be generated. if (method.AssociatedSymbol is IPropertySymbol property) { if (PropertyGenerator.CanBeGenerated(property)) { return(destination); } } if (destination is TypeDeclarationSyntax typeDeclaration) { if (method.IsConstructor()) { return(Cast <TDeclarationNode>(ConstructorGenerator.AddConstructorTo( typeDeclaration, method, options, availableIndices))); } if (method.IsDestructor()) { return(Cast <TDeclarationNode>(DestructorGenerator.AddDestructorTo(typeDeclaration, method, options, availableIndices))); } if (method.MethodKind == MethodKind.Conversion) { return(Cast <TDeclarationNode>(ConversionGenerator.AddConversionTo( typeDeclaration, method, options, availableIndices))); } if (method.MethodKind == MethodKind.UserDefinedOperator) { return(Cast <TDeclarationNode>(OperatorGenerator.AddOperatorTo( typeDeclaration, method, options, availableIndices))); } return(Cast <TDeclarationNode>(MethodGenerator.AddMethodTo( typeDeclaration, method, options, availableIndices))); } if (method.IsConstructor() || method.IsDestructor()) { return(destination); } if (destination is CompilationUnitSyntax compilationUnit) { return(Cast <TDeclarationNode>( MethodGenerator.AddMethodTo(compilationUnit, method, options, availableIndices))); } var ns = Cast <BaseNamespaceDeclarationSyntax>(destination); return(Cast <TDeclarationNode>( MethodGenerator.AddMethodTo(ns, method, options, availableIndices))); }
public static MemberDeclarationSyntax GenerateNamedTypeDeclaration( ICodeGenerationService service, INamedTypeSymbol namedType, CodeGenerationDestination destination, CodeGenerationOptions options) { options = options ?? CodeGenerationOptions.Default; var declaration = GetDeclarationSyntaxWithoutMembers(namedType, destination, options); // If we are generating members then make sure to exclude properties that cannot be generated. // Reason: Calling AddProperty on a propertysymbol that can't be generated (like one with params) causes // the getter and setter to get generated instead. Since the list of members is going to include // the method symbols for the getter and setter, we don't want to generate them twice. declaration = options.GenerateMembers && namedType.TypeKind != TypeKind.Delegate ? service.AddMembers(declaration, GetMembers(namedType).Where(s => s.Kind != SymbolKind.Property || PropertyGenerator.CanBeGenerated((IPropertySymbol)s)), options) : declaration; return(AddCleanupAnnotationsTo(ConditionallyAddDocumentationCommentTo(declaration, namedType, options))); }
public override SyntaxNode CreatePropertyDeclaration( IPropertySymbol property, CodeGenerationDestination destination, CodeGenerationOptions options) { return(PropertyGenerator.GeneratePropertyDeclaration(property, destination, options)); }
public static MemberDeclarationSyntax GenerateNamedTypeDeclaration( ICodeGenerationService service, INamedTypeSymbol namedType, CodeGenerationDestination destination, CSharpCodeGenerationContextInfo info, CancellationToken cancellationToken) { var declaration = GetDeclarationSyntaxWithoutMembers(namedType, destination, info); // If we are generating members then make sure to exclude properties that cannot be generated. // Reason: Calling AddProperty on a propertysymbol that can't be generated (like one with params) causes // the getter and setter to get generated instead. Since the list of members is going to include // the method symbols for the getter and setter, we don't want to generate them twice. var members = GetMembers(namedType).Where(s => s.Kind != SymbolKind.Property || PropertyGenerator.CanBeGenerated((IPropertySymbol)s)) .ToImmutableArray(); if (namedType.IsRecord) { declaration = GenerateRecordMembers(service, info, (RecordDeclarationSyntax)declaration, members, cancellationToken); } else { // If we're generating a ComImport type, then do not attempt to do any // reordering of members. if (namedType.IsComImport) { info = info.WithContext(info.Context.With(autoInsertionLocation: false, sortMembers: false)); } if (info.Context.GenerateMembers && namedType.TypeKind != TypeKind.Delegate) { declaration = service.AddMembers(declaration, members, info, cancellationToken); } } return(AddFormatterAndCodeGeneratorAnnotationsTo(ConditionallyAddDocumentationCommentTo(declaration, namedType, info, cancellationToken))); }