private static MethodDeclarationSyntax GenerateMethodDeclarationWorker( IMethodSymbol method, CodeGenerationDestination destination, CodeGenerationOptions options) { var hasNoBody = !options.GenerateMethodBodies || destination == CodeGenerationDestination.InterfaceType || method.IsAbstract; var explicitInterfaceSpecifier = GenerateExplicitInterfaceSpecifier(method.ExplicitInterfaceImplementations); var returnType = method.ReturnsByRef ? method.ReturnType.GenerateRefTypeSyntax() : method.ReturnType.GenerateTypeSyntax(); return AddCleanupAnnotationsTo(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())); }
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()); }
public static MemberDeclarationSyntax GenerateNamedTypeDeclaration( ICodeGenerationService service, INamedTypeSymbol namedType, CodeGenerationDestination destination, CodeGenerationOptions options, CancellationToken cancellationToken) { options = 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 AddCleanupAnnotationsTo(ConditionallyAddDocumentationCommentTo(declaration, namedType, options)); }
internal static ConstructorDeclarationSyntax GenerateConstructorDeclaration( IMethodSymbol constructor, CodeGenerationDestination destination, CodeGenerationOptions options) { options = options ?? CodeGenerationOptions.Default; var reusableSyntax = GetReuseableSyntaxNodeForSymbol<ConstructorDeclarationSyntax>(constructor, options); if (reusableSyntax != null) { return reusableSyntax; } bool 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)); return AddCleanupAnnotationsTo( ConditionallyAddDocumentationCommentTo(declaration, constructor, options)); }
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 ConversionOperatorDeclarationSyntax GenerateConversionDeclaration( IMethodSymbol method, CodeGenerationDestination destination, CodeGenerationOptions options) { var declaration = GenerateConversionDeclarationWorker(method, destination, options); return AddCleanupAnnotationsTo(AddAnnotationsTo(method, ConditionallyAddDocumentationCommentTo(declaration, method, options))); }
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)))); }
internal static OperatorDeclarationSyntax GenerateOperatorDeclaration( IMethodSymbol method, CodeGenerationDestination destination, CodeGenerationOptions options) { var reusableSyntax = GetReuseableSyntaxNodeForSymbol<OperatorDeclarationSyntax>(method, options); if (reusableSyntax != null) { return reusableSyntax; } var declaration = GenerateOperatorDeclarationWorker(method, destination, options); return AddAnnotationsTo(method, ConditionallyAddDocumentationCommentTo(declaration, method, options)); }
public static MethodDeclarationSyntax GenerateMethodDeclaration( IMethodSymbol method, CodeGenerationDestination destination, CodeGenerationOptions options) { options = options ?? CodeGenerationOptions.Default; var reusableSyntax = GetReuseableSyntaxNodeForSymbol<MethodDeclarationSyntax>(method, options); if (reusableSyntax != null) { return reusableSyntax; } var declaration = GenerateMethodDeclarationWorker(method, destination, options); return AddAnnotationsTo(method, ConditionallyAddDocumentationCommentTo(declaration, method, options)); }
public static MemberDeclarationSyntax GeneratePropertyOrIndexer( IPropertySymbol property, CodeGenerationDestination destination, CodeGenerationOptions options) { var reusableSyntax = GetReuseableSyntaxNodeForSymbol<MemberDeclarationSyntax>(property, options); if (reusableSyntax != null) { return reusableSyntax; } var declaration = property.IsIndexer ? GenerateIndexerDeclaration(property, destination, options) : GeneratePropertyDeclaration(property, destination, options); return ConditionallyAddDocumentationCommentTo(declaration, property, options); }
public static FieldDeclarationSyntax GenerateFieldDeclaration( IFieldSymbol field, CodeGenerationDestination destination, CodeGenerationOptions options) { var reusableSyntax = GetReuseableSyntaxNodeForSymbol<VariableDeclaratorSyntax>(field, options); if (reusableSyntax != null) { var variableDeclaration = reusableSyntax.Parent as VariableDeclarationSyntax; if (variableDeclaration != null) { var newVariableDeclaratorsList = new SeparatedSyntaxList<VariableDeclaratorSyntax>().Add(reusableSyntax); var newVariableDeclaration = variableDeclaration.WithVariables(newVariableDeclaratorsList); var fieldDecl = variableDeclaration.Parent as FieldDeclarationSyntax; if (fieldDecl != null) { return fieldDecl.WithDeclaration(newVariableDeclaration); } } } 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( field.Type.GenerateTypeSyntax(), SyntaxFactory.SingletonSeparatedList( AddAnnotationsTo(field, SyntaxFactory.VariableDeclarator(field.Name.ToIdentifierToken(), null, initializer))))); return AddCleanupAnnotationsTo( ConditionallyAddDocumentationCommentTo(fieldDeclaration, field, options)); }
private static EnumDeclarationSyntax GenerateEnumDeclaration( INamedTypeSymbol namedType, CodeGenerationDestination destination, CodeGenerationOptions options) { var baseList = namedType.EnumUnderlyingType != null && namedType.EnumUnderlyingType.SpecialType != SpecialType.System_Int32 ? SyntaxFactory.BaseList(SyntaxFactory.SingletonSeparatedList<BaseTypeSyntax>(SyntaxFactory.SimpleBaseType(namedType.EnumUnderlyingType.GenerateTypeSyntax()))) : null; return SyntaxFactory.EnumDeclaration( GenerateAttributeDeclarations(namedType, options), GenerateModifiers(namedType, destination, options), namedType.Name.ToIdentifierToken(), baseList: baseList, members: default(SeparatedSyntaxList<EnumMemberDeclarationSyntax>)); }
private static MemberDeclarationSyntax GenerateNamedTypeDeclarationWorker( INamedTypeSymbol namedType, CodeGenerationDestination destination, CodeGenerationOptions options) { if (namedType.TypeKind == TypeKind.Enum) { return GenerateEnumDeclaration(namedType, destination, options); } else if (namedType.TypeKind == TypeKind.Delegate) { return GenerateDelegateDeclaration(namedType, destination, options); } var kind = namedType.TypeKind == TypeKind.Struct ? SyntaxKind.StructDeclaration : namedType.TypeKind == TypeKind.Interface ? SyntaxKind.InterfaceDeclaration : SyntaxKind.ClassDeclaration; var typeDeclaration = SyntaxFactory.TypeDeclaration(kind, namedType.Name.ToIdentifierToken()) .WithAttributeLists(GenerateAttributeDeclarations(namedType, options)) .WithModifiers(GenerateModifiers(namedType, destination, options)) .WithTypeParameterList(GenerateTypeParameterList(namedType, options)) .WithBaseList(GenerateBaseList(namedType)) .WithConstraintClauses(GenerateConstraintClauses(namedType)); return typeDeclaration; }
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()); }
public static MemberDeclarationSyntax GenerateEventDeclaration( IEventSymbol @event, CodeGenerationDestination destination, CodeGenerationOptions options) { var reusableSyntax = GetReuseableSyntaxNodeForSymbol<MemberDeclarationSyntax>(@event, options); if (reusableSyntax != null) { return reusableSyntax; } var declaration = !options.GenerateMethodBodies || @event.IsAbstract || @event.AddMethod == null || @event.RemoveMethod == null ? GenerateEventFieldDeclaration(@event, destination, options) : GenerateEventDeclarationWorker(@event, destination, options); return ConditionallyAddDocumentationCommentTo(declaration, @event, options); }
public abstract SyntaxNode CreateEventDeclaration( IEventSymbol @event, CodeGenerationDestination destination, CodeGenerationOptions?options );
private static bool HasAccessorBodies( IEventSymbol @event, CodeGenerationDestination destination, IMethodSymbol accessor) { return destination != CodeGenerationDestination.InterfaceType && [email protected] && accessor != null && !accessor.IsAbstract; }
private static SyntaxTokenList GenerateModifiers( IEventSymbol @event, CodeGenerationDestination destination, CodeGenerationOptions options) { var tokens = new List<SyntaxToken>(); // Most modifiers not allowed if we're an explicit impl. if ([email protected]()) { if (destination != CodeGenerationDestination.InterfaceType) { AddAccessibilityModifiers(@event.DeclaredAccessibility, tokens, options, Accessibility.Private); if (@event.IsStatic) { tokens.Add(SyntaxFactory.Token(SyntaxKind.StaticKeyword)); } if (@event.IsAbstract) { tokens.Add(SyntaxFactory.Token(SyntaxKind.AbstractKeyword)); } if (@event.IsOverride) { tokens.Add(SyntaxFactory.Token(SyntaxKind.OverrideKeyword)); } } } if (CodeGenerationEventInfo.GetIsUnsafe(@event)) { tokens.Add(SyntaxFactory.Token(SyntaxKind.UnsafeKeyword)); } return tokens.ToSyntaxTokenList(); }
public abstract SyntaxNode CreatePropertyDeclaration( IPropertySymbol property, CodeGenerationDestination destination, CodeGenerationOptions?options );
private static AccessorDeclarationSyntax GenerateAccessorDeclaration( IEventSymbol @event, IMethodSymbol accessor, SyntaxKind kind, CodeGenerationDestination destination, CodeGenerationOptions options) { var hasBody = options.GenerateMethodBodies && HasAccessorBodies(@event, destination, accessor); return accessor == null ? null : GenerateAccessorDeclaration(accessor, kind, hasBody); }
private static SyntaxTokenList GenerateModifiers( INamedTypeSymbol namedType, CodeGenerationDestination destination, CodeGenerationOptions options) { var tokens = new List<SyntaxToken>(); var defaultAccessibility = destination == CodeGenerationDestination.CompilationUnit || destination == CodeGenerationDestination.Namespace ? Accessibility.Internal : Accessibility.Private; AddAccessibilityModifiers(namedType.DeclaredAccessibility, tokens, options, defaultAccessibility); if (namedType.IsStatic) { tokens.Add(SyntaxFactory.Token(SyntaxKind.StaticKeyword)); } else { if (namedType.TypeKind == TypeKind.Class) { if (namedType.IsAbstract) { tokens.Add(SyntaxFactory.Token(SyntaxKind.AbstractKeyword)); } if (namedType.IsSealed) { tokens.Add(SyntaxFactory.Token(SyntaxKind.SealedKeyword)); } } } return tokens.ToSyntaxTokenList(); }
public abstract SyntaxNode CreateMethodDeclaration( IMethodSymbol method, CodeGenerationDestination destination, CodeGenerationOptions?options );
public abstract SyntaxNode CreateFieldDeclaration( IFieldSymbol field, CodeGenerationDestination destination, CodeGenerationOptions?options );
private static AccessorListSyntax GenerateAccessorList( IPropertySymbol property, CodeGenerationDestination destination, CodeGenerationOptions options) { var accessors = new List<AccessorDeclarationSyntax> { GenerateAccessorDeclaration(property, property.GetMethod, SyntaxKind.GetAccessorDeclaration, destination, options), GenerateAccessorDeclaration(property, property.SetMethod, SyntaxKind.SetAccessorDeclaration, destination, options), }; return accessors[0] == null && accessors[1] == null ? null : SyntaxFactory.AccessorList(accessors.WhereNotNull().ToSyntaxList()); }
private static AccessorDeclarationSyntax GenerateAccessorDeclaration( IPropertySymbol property, IMethodSymbol accessor, SyntaxKind kind, CodeGenerationDestination destination, CodeGenerationOptions options) { var hasBody = options.GenerateMethodBodies && HasAccessorBodies(property, destination, accessor); return accessor == null ? null : GenerateAccessorDeclaration(property, accessor, kind, hasBody, options); }
private static SyntaxTokenList GenerateModifiers( IPropertySymbol property, CodeGenerationDestination destination, CodeGenerationOptions options) { var tokens = new List<SyntaxToken>(); // Most modifiers not allowed if we're an explicit impl. if (!property.ExplicitInterfaceImplementations.Any()) { if (destination != CodeGenerationDestination.CompilationUnit && destination != CodeGenerationDestination.InterfaceType) { AddAccessibilityModifiers(property.DeclaredAccessibility, tokens, options, Accessibility.Private); if (property.IsStatic) { tokens.Add(SyntaxFactory.Token(SyntaxKind.StaticKeyword)); } if (property.IsSealed) { tokens.Add(SyntaxFactory.Token(SyntaxKind.SealedKeyword)); } if (property.IsOverride) { tokens.Add(SyntaxFactory.Token(SyntaxKind.OverrideKeyword)); } if (property.IsVirtual) { tokens.Add(SyntaxFactory.Token(SyntaxKind.VirtualKeyword)); } if (property.IsAbstract) { tokens.Add(SyntaxFactory.Token(SyntaxKind.AbstractKeyword)); } } } if (CodeGenerationPropertyInfo.GetIsUnsafe(property)) { tokens.Add(SyntaxFactory.Token(SyntaxKind.UnsafeKeyword)); } return tokens.ToSyntaxTokenList(); }
private static bool HasAccessorBodies( IPropertySymbol property, CodeGenerationDestination destination, IMethodSymbol accessor) { return destination != CodeGenerationDestination.InterfaceType && !property.IsAbstract && accessor != null && !accessor.IsAbstract; }
private static MemberDeclarationSyntax GetDeclarationSyntaxWithoutMembers( INamedTypeSymbol namedType, CodeGenerationDestination destination, CodeGenerationOptions options) { var reusableDeclarationSyntax = GetReuseableSyntaxNodeForSymbol<MemberDeclarationSyntax>(namedType, options); if (reusableDeclarationSyntax == null) { return GenerateNamedTypeDeclarationWorker(namedType, destination, options); } return RemoveAllMembers(reusableDeclarationSyntax); }
private static SyntaxTokenList GenerateModifiers( IPropertySymbol property, CodeGenerationDestination destination, CSharpCodeGenerationContextInfo info) { var tokens = ArrayBuilder <SyntaxToken> .GetInstance(); // Most modifiers not allowed if we're an explicit impl. if (!property.ExplicitInterfaceImplementations.Any()) { // If we're generating into an interface, then allow modifiers for static abstract members if (destination is CodeGenerationDestination.InterfaceType) { if (property.IsStatic) { tokens.Add(SyntaxFactory.Token(SyntaxKind.StaticKeyword)); if (property.IsAbstract) { tokens.Add(SyntaxFactory.Token(SyntaxKind.AbstractKeyword)); } } } else if (destination is not CodeGenerationDestination.CompilationUnit) { AddAccessibilityModifiers(property.DeclaredAccessibility, tokens, info, Accessibility.Private); if (property.IsStatic) { tokens.Add(SyntaxFactory.Token(SyntaxKind.StaticKeyword)); } // note: explicit interface impls are allowed to be 'readonly' but it never actually affects callers // because of the boxing requirement in order to call the method. // therefore it seems like a small oversight to leave out the keyword for an explicit impl from metadata. var hasAllReadOnlyAccessors = property.GetMethod?.IsReadOnly != false && property.SetMethod?.IsReadOnly != false; // Don't show the readonly modifier if the containing type is already readonly if (hasAllReadOnlyAccessors && !property.ContainingType.IsReadOnly) { tokens.Add(SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword)); } if (property.IsSealed) { tokens.Add(SyntaxFactory.Token(SyntaxKind.SealedKeyword)); } if (property.IsOverride) { tokens.Add(SyntaxFactory.Token(SyntaxKind.OverrideKeyword)); } if (property.IsVirtual) { tokens.Add(SyntaxFactory.Token(SyntaxKind.VirtualKeyword)); } if (property.IsAbstract) { tokens.Add(SyntaxFactory.Token(SyntaxKind.AbstractKeyword)); } if (property.IsRequired) { tokens.Add(SyntaxFactory.Token(SyntaxKind.RequiredKeyword)); } } } if (CodeGenerationPropertyInfo.GetIsUnsafe(property)) { tokens.Add(SyntaxFactory.Token(SyntaxKind.UnsafeKeyword)); } return(tokens.ToSyntaxTokenList()); }
private 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); var accessorList = GenerateAccessorList(property, destination, options); 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: accessorList, expressionBody: default(ArrowExpressionClauseSyntax), initializer: initializer))); }
public abstract SyntaxNode CreateNamedTypeDeclaration( INamedTypeSymbol namedType, CodeGenerationDestination destination, CodeGenerationOptions?options, CancellationToken cancellationToken );
private static SyntaxTokenList GenerateModifiers( IMethodSymbol method, CodeGenerationDestination destination, CodeGenerationOptions options) { var tokens = new List<SyntaxToken>(); // Only "unsafe" modifier allowed if we're an explicit impl. if (method.ExplicitInterfaceImplementations.Any()) { if (CodeGenerationMethodInfo.GetIsUnsafe(method)) { tokens.Add(SyntaxFactory.Token(SyntaxKind.UnsafeKeyword)); } } else { // If we're generating into an interface, then we don't use any modifiers. if (destination != CodeGenerationDestination.CompilationUnit && destination != CodeGenerationDestination.Namespace && destination != CodeGenerationDestination.InterfaceType) { AddAccessibilityModifiers(method.DeclaredAccessibility, tokens, options, Accessibility.Private); if (method.IsAbstract) { tokens.Add(SyntaxFactory.Token(SyntaxKind.AbstractKeyword)); } if (method.IsSealed) { tokens.Add(SyntaxFactory.Token(SyntaxKind.SealedKeyword)); } if (method.IsStatic) { tokens.Add(SyntaxFactory.Token(SyntaxKind.StaticKeyword)); } if (method.IsOverride) { tokens.Add(SyntaxFactory.Token(SyntaxKind.OverrideKeyword)); } if (method.IsVirtual) { tokens.Add(SyntaxFactory.Token(SyntaxKind.VirtualKeyword)); } if (CodeGenerationMethodInfo.GetIsPartial(method) && !method.IsAsync) { tokens.Add(SyntaxFactory.Token(SyntaxKind.PartialKeyword)); } } if (CodeGenerationMethodInfo.GetIsUnsafe(method)) { tokens.Add(SyntaxFactory.Token(SyntaxKind.UnsafeKeyword)); } if (CodeGenerationMethodInfo.GetIsNew(method)) { tokens.Add(SyntaxFactory.Token(SyntaxKind.NewKeyword)); } } if (destination != CodeGenerationDestination.InterfaceType) { if (CodeGenerationMethodInfo.GetIsAsync(method)) { tokens.Add(SyntaxFactory.Token(SyntaxKind.AsyncKeyword)); } } if (CodeGenerationMethodInfo.GetIsPartial(method) && method.IsAsync) { tokens.Add(SyntaxFactory.Token(SyntaxKind.PartialKeyword)); } return tokens.ToSyntaxTokenList(); }
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 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))); }
private static AccessorListSyntax GenerateAccessorList( IEventSymbol @event, CodeGenerationDestination destination, CodeGenerationOptions options) { var accessors = new List<AccessorDeclarationSyntax> { GenerateAccessorDeclaration(@event, @event.AddMethod, SyntaxKind.AddAccessorDeclaration, destination, options), GenerateAccessorDeclaration(@event, @event.RemoveMethod, SyntaxKind.RemoveAccessorDeclaration, destination, options), }; return SyntaxFactory.AccessorList(accessors.WhereNotNull().ToSyntaxList()); }
protected override Accessibility GetDefaultAccessibility(SymbolKind targetSymbolKind, CodeGenerationDestination destination) { switch (targetSymbolKind) { case SymbolKind.Field: case SymbolKind.Method: case SymbolKind.Property: case SymbolKind.Event: return Accessibility.Private; case SymbolKind.NamedType: switch (destination) { case CodeGenerationDestination.ClassType: case CodeGenerationDestination.EnumType: case CodeGenerationDestination.InterfaceType: case CodeGenerationDestination.StructType: return Accessibility.Private; default: return Accessibility.Internal; } default: Debug.Fail("Invalid symbol kind: " + targetSymbolKind); throw Exceptions.ThrowEFail(); } }
private static SyntaxTokenList GenerateModifiers( IMethodSymbol method, CodeGenerationDestination destination, CodeGenerationOptions options) { var tokens = new List <SyntaxToken>(); // Only "unsafe" modifier allowed if we're an explicit impl. if (method.ExplicitInterfaceImplementations.Any()) { if (CodeGenerationMethodInfo.GetIsUnsafe(method)) { tokens.Add(SyntaxFactory.Token(SyntaxKind.UnsafeKeyword)); } } else { // If we're generating into an interface, then we don't use any modifiers. if (destination != CodeGenerationDestination.CompilationUnit && destination != CodeGenerationDestination.Namespace && destination != CodeGenerationDestination.InterfaceType) { AddAccessibilityModifiers(method.DeclaredAccessibility, tokens, options, Accessibility.Private); if (method.IsAbstract) { tokens.Add(SyntaxFactory.Token(SyntaxKind.AbstractKeyword)); } if (method.IsSealed) { tokens.Add(SyntaxFactory.Token(SyntaxKind.SealedKeyword)); } if (method.IsStatic) { tokens.Add(SyntaxFactory.Token(SyntaxKind.StaticKeyword)); } if (method.IsOverride) { tokens.Add(SyntaxFactory.Token(SyntaxKind.OverrideKeyword)); } if (method.IsVirtual) { tokens.Add(SyntaxFactory.Token(SyntaxKind.VirtualKeyword)); } if (CodeGenerationMethodInfo.GetIsPartial(method) && !method.IsAsync) { tokens.Add(SyntaxFactory.Token(SyntaxKind.PartialKeyword)); } } if (CodeGenerationMethodInfo.GetIsUnsafe(method)) { tokens.Add(SyntaxFactory.Token(SyntaxKind.UnsafeKeyword)); } if (CodeGenerationMethodInfo.GetIsNew(method)) { tokens.Add(SyntaxFactory.Token(SyntaxKind.NewKeyword)); } } if (destination != CodeGenerationDestination.InterfaceType) { if (CodeGenerationMethodInfo.GetIsAsync(method)) { tokens.Add(SyntaxFactory.Token(SyntaxKind.AsyncKeyword)); } } if (CodeGenerationMethodInfo.GetIsPartial(method) && method.IsAsync) { tokens.Add(SyntaxFactory.Token(SyntaxKind.PartialKeyword)); } return(tokens.ToSyntaxTokenList()); }