public static BracketedParameterListSyntax GenerateBracketedParameterList( ImmutableArray <IParameterSymbol> parameterDefinitions, bool isExplicit, CSharpCodeGenerationOptions options) { return(GenerateBracketedParameterList((IList <IParameterSymbol>)parameterDefinitions, isExplicit, options)); }
private static SyntaxTokenList GenerateModifiers(IFieldSymbol field, CSharpCodeGenerationOptions options) { var tokens = ArrayBuilder <SyntaxToken> .GetInstance(); AddAccessibilityModifiers(field.DeclaredAccessibility, tokens, options, Accessibility.Private); if (field.IsConst) { tokens.Add(SyntaxFactory.Token(SyntaxKind.ConstKeyword)); } else { if (field.IsStatic) { tokens.Add(SyntaxFactory.Token(SyntaxKind.StaticKeyword)); } if (field.IsReadOnly) { tokens.Add(SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword)); } } if (CodeGenerationFieldInfo.GetIsUnsafe(field)) { tokens.Add(SyntaxFactory.Token(SyntaxKind.UnsafeKeyword)); } return(tokens.ToSyntaxTokenListAndFree()); }
public static FieldDeclarationSyntax GenerateFieldDeclaration( IFieldSymbol field, CSharpCodeGenerationOptions options, CancellationToken cancellationToken) { var reusableSyntax = GetReuseableSyntaxNodeForSymbol <FieldDeclarationSyntax>(field, options); if (reusableSyntax != null) { return(reusableSyntax); } var initializer = CodeGenerationFieldInfo.GetInitializer(field) is ExpressionSyntax initializerNode ? 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(AddFormatterAndCodeGeneratorAnnotationsTo( ConditionallyAddDocumentationCommentTo(fieldDeclaration, field, options, cancellationToken))); }
public static SyntaxList <AttributeListSyntax> GenerateAttributeLists( ImmutableArray <AttributeData> attributes, CSharpCodeGenerationOptions options, SyntaxToken?target = null) { if (options.Context.MergeAttributes) { var attributeNodes = attributes.OrderBy(a => a.AttributeClass?.Name) .Select(a => TryGenerateAttribute(a, options)) .WhereNotNull().ToList(); return(attributeNodes.Count == 0 ? default : SyntaxFactory.SingletonList(SyntaxFactory.AttributeList( target.HasValue ? SyntaxFactory.AttributeTargetSpecifier(target.Value) : null, SyntaxFactory.SeparatedList(attributeNodes)))); } else { var attributeDeclarations = attributes.OrderBy(a => a.AttributeClass?.Name) .Select(a => TryGenerateAttributeDeclaration(a, target, options)) .WhereNotNull().ToList(); return(attributeDeclarations.Count == 0 ? default : SyntaxFactory.List <AttributeListSyntax>(attributeDeclarations)); } }
private static MemberDeclarationSyntax GeneratePropertyDeclaration( IPropertySymbol property, CodeGenerationDestination destination, CSharpCodeGenerationOptions options) { var initializer = CodeGenerationPropertyInfo.GetInitializer(property) is ExpressionSyntax initializerNode ? SyntaxFactory.EqualsValueClause(initializerNode) : null; var explicitInterfaceSpecifier = GenerateExplicitInterfaceSpecifier(property.ExplicitInterfaceImplementations); var accessorList = GenerateAccessorList(property, destination, options); var propertyDeclaration = SyntaxFactory.PropertyDeclaration( attributeLists: AttributeGenerator.GenerateAttributeLists(property.GetAttributes(), options), modifiers: GenerateModifiers(property, destination, options), type: GenerateTypeSyntax(property), explicitInterfaceSpecifier: explicitInterfaceSpecifier, identifier: property.Name.ToIdentifierToken(), accessorList: accessorList, expressionBody: null, initializer: initializer); propertyDeclaration = UseExpressionBodyIfDesired(options, propertyDeclaration); return(AddFormatterAndCodeGeneratorAnnotationsTo( AddAnnotationsTo(property, propertyDeclaration))); }
private static AttributeSyntax?TryGenerateAttribute(AttributeData attribute, CSharpCodeGenerationOptions options) { if (IsCompilerInternalAttribute(attribute)) { return(null); } if (!options.Context.MergeAttributes) { var reusableSyntax = GetReuseableSyntaxNodeForAttribute <AttributeSyntax>(attribute, options); if (reusableSyntax != null) { return(reusableSyntax); } } if (attribute.AttributeClass == null) { return(null); } var attributeArguments = GenerateAttributeArgumentList(attribute); return(attribute.AttributeClass.GenerateTypeSyntax() is NameSyntax nameSyntax ? SyntaxFactory.Attribute(nameSyntax, attributeArguments) : null); }
private static OperatorDeclarationSyntax GenerateOperatorDeclarationWorker( IMethodSymbol method, CSharpCodeGenerationOptions options) { var hasNoBody = !options.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 operatorDecl = SyntaxFactory.OperatorDeclaration( attributeLists: AttributeGenerator.GenerateAttributeLists(method.GetAttributes(), options), modifiers: GenerateModifiers(method), returnType: method.ReturnType.GenerateTypeSyntax(), explicitInterfaceSpecifier: GenerateExplicitInterfaceSpecifier(method.ExplicitInterfaceImplementations), operatorKeyword: SyntaxFactory.Token(SyntaxKind.OperatorKeyword), operatorToken: operatorToken, parameterList: ParameterGenerator.GenerateParameterList(method.Parameters, isExplicit: false, options: options), body: hasNoBody ? null : StatementGenerator.GenerateBlock(method), expressionBody: null, semicolonToken: hasNoBody ? SyntaxFactory.Token(SyntaxKind.SemicolonToken) : new SyntaxToken()); operatorDecl = UseExpressionBodyIfDesired(options, operatorDecl); return(operatorDecl); }
private static ConversionOperatorDeclarationSyntax GenerateConversionDeclarationWorker( IMethodSymbol method, CSharpCodeGenerationOptions options) { var hasNoBody = !options.Context.GenerateMethodBodies || method.IsExtern; var reusableSyntax = GetReuseableSyntaxNodeForSymbol <ConversionOperatorDeclarationSyntax>(method, options); if (reusableSyntax != null) { return(reusableSyntax); } 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(), 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(options, declaration); return(declaration); }
public static TypeParameterListSyntax?GenerateTypeParameterList( ImmutableArray <ITypeParameterSymbol> typeParameters, CSharpCodeGenerationOptions options) { return(typeParameters.Length == 0 ? null : SyntaxFactory.TypeParameterList( SyntaxFactory.SeparatedList(typeParameters.Select(t => GenerateTypeParameter(t, options))))); }
private static SyntaxTokenList GenerateModifiers( IPropertySymbol property, CodeGenerationDestination destination, CSharpCodeGenerationOptions options) { var tokens = ArrayBuilder <SyntaxToken> .GetInstance(); // Most modifiers not allowed if we're an explicit impl. if (!property.ExplicitInterfaceImplementations.Any()) { if (destination is not CodeGenerationDestination.CompilationUnit and not CodeGenerationDestination.InterfaceType) { AddAccessibilityModifiers(property.DeclaredAccessibility, tokens, options, 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 (CodeGenerationPropertyInfo.GetIsUnsafe(property)) { tokens.Add(SyntaxFactory.Token(SyntaxKind.UnsafeKeyword)); } return(tokens.ToSyntaxTokenList()); }
public static ParameterListSyntax GenerateParameterList( IEnumerable <IParameterSymbol> parameterDefinitions, bool isExplicit, CSharpCodeGenerationOptions options) { var parameters = GetParameters(parameterDefinitions, isExplicit, options); return(SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList(parameters))); }
internal static ConversionOperatorDeclarationSyntax GenerateConversionDeclaration( IMethodSymbol method, CSharpCodeGenerationOptions options, CancellationToken cancellationToken) { var declaration = GenerateConversionDeclarationWorker(method, options); return(AddFormatterAndCodeGeneratorAnnotationsTo(AddAnnotationsTo(method, ConditionallyAddDocumentationCommentTo(declaration, method, options, cancellationToken)))); }
private static AccessorListSyntax GenerateAccessorList( IEventSymbol @event, CodeGenerationDestination destination, CSharpCodeGenerationOptions 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())); }
public static SyntaxNode UpdateCompilationUnitOrNamespaceDeclaration( ICodeGenerationService service, SyntaxNode declaration, IList <ISymbol> newMembers, CSharpCodeGenerationOptions options, CancellationToken cancellationToken) { declaration = RemoveAllMembers(declaration); declaration = service.AddMembers(declaration, newMembers, options, cancellationToken); return(AddFormatterAndCodeGeneratorAnnotationsTo(declaration)); }
internal static TypeDeclarationSyntax AddOperatorTo( TypeDeclarationSyntax destination, IMethodSymbol method, CSharpCodeGenerationOptions options, IList <bool>?availableIndices, CancellationToken cancellationToken) { var methodDeclaration = GenerateOperatorDeclaration(method, options, cancellationToken); var members = Insert(destination.Members, methodDeclaration, options, availableIndices, after: LastOperator); return(AddMembersTo(destination, members, cancellationToken)); }
public static BracketedParameterListSyntax GenerateBracketedParameterList( IEnumerable <IParameterSymbol> parameterDefinitions, bool isExplicit, CSharpCodeGenerationOptions options) { // Bracketed parameter lists come from indexers. Those don't have type parameters, so we // could never have a typeParameterMapping. var parameters = GetParameters(parameterDefinitions, isExplicit, options); return(SyntaxFactory.BracketedParameterList( parameters: SyntaxFactory.SeparatedList(parameters))); }
private static MemberDeclarationSyntax GenerateEventFieldDeclaration( IEventSymbol @event, CodeGenerationDestination destination, CSharpCodeGenerationOptions options) { return(AddFormatterAndCodeGeneratorAnnotationsTo( 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, CSharpCodeGenerationOptions 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(), accessorList: GenerateAccessorList(@event, destination, options)))); }
public static TypeDeclarationSyntax AddNamedTypeTo( ICodeGenerationService service, TypeDeclarationSyntax destination, INamedTypeSymbol namedType, CSharpCodeGenerationOptions options, IList <bool>?availableIndices, CancellationToken cancellationToken) { var declaration = GenerateNamedTypeDeclaration(service, namedType, GetDestination(destination), options, cancellationToken); var members = Insert(destination.Members, declaration, options, availableIndices); return(AddMembersTo(destination, members, cancellationToken)); }
private static AttributeListSyntax?TryGenerateAttributeDeclaration( AttributeData attribute, SyntaxToken?target, CSharpCodeGenerationOptions options) { var attributeSyntax = TryGenerateAttribute(attribute, options); return(attributeSyntax == null ? null : SyntaxFactory.AttributeList( target.HasValue ? SyntaxFactory.AttributeTargetSpecifier(target.Value) : null, SyntaxFactory.SingletonSeparatedList(attributeSyntax))); }
private static AccessorDeclarationSyntax?GenerateAccessorDeclaration( IEventSymbol @event, IMethodSymbol?accessor, SyntaxKind kind, CodeGenerationDestination destination, CSharpCodeGenerationOptions options) { var hasBody = options.Context.GenerateMethodBodies && HasAccessorBodies(@event, destination, accessor); return(accessor == null ? null : GenerateAccessorDeclaration(accessor, kind, hasBody)); }
private static SyntaxNode GetDeclarationSyntaxWithoutMembers( INamespaceSymbol @namespace, INamespaceSymbol innermostNamespace, string name, CodeGenerationDestination destination, CSharpCodeGenerationOptions options) { var reusableSyntax = GetReuseableSyntaxNodeForSymbol <SyntaxNode>(@namespace, options); return(reusableSyntax == null ? GenerateNamespaceDeclarationWorker(name, innermostNamespace, destination, options) : RemoveAllMembers(reusableSyntax)); }
public static CompilationUnitSyntax AddNamedTypeTo( ICodeGenerationService service, CompilationUnitSyntax destination, INamedTypeSymbol namedType, CSharpCodeGenerationOptions options, IList <bool>?availableIndices, CancellationToken cancellationToken) { var declaration = GenerateNamedTypeDeclaration(service, namedType, CodeGenerationDestination.CompilationUnit, options, cancellationToken); var members = Insert(destination.Members, declaration, options, availableIndices); return(destination.WithMembers(members)); }
internal static BaseNamespaceDeclarationSyntax AddMethodTo( BaseNamespaceDeclarationSyntax destination, IMethodSymbol method, CSharpCodeGenerationOptions options, IList <bool>?availableIndices, CancellationToken cancellationToken) { var declaration = GenerateMethodDeclaration(method, CodeGenerationDestination.Namespace, options, cancellationToken); var members = Insert(destination.Members, declaration, options, availableIndices, after: LastMethod); return(destination.WithMembers(members.ToSyntaxList())); }
internal static TypeDeclarationSyntax AddMethodTo( TypeDeclarationSyntax destination, IMethodSymbol method, CSharpCodeGenerationOptions options, IList <bool>?availableIndices, CancellationToken cancellationToken) { var methodDeclaration = GenerateMethodDeclaration( method, GetDestination(destination), options, cancellationToken); // Create a clone of the original type with the new method inserted. var members = Insert(destination.Members, methodDeclaration, options, availableIndices, after: LastMethod); return(AddMembersTo(destination, members, cancellationToken)); }
public static BaseNamespaceDeclarationSyntax AddNamedTypeTo( ICodeGenerationService service, BaseNamespaceDeclarationSyntax destination, INamedTypeSymbol namedType, CSharpCodeGenerationOptions options, IList <bool>?availableIndices, CancellationToken cancellationToken) { var declaration = GenerateNamedTypeDeclaration(service, namedType, CodeGenerationDestination.Namespace, options, cancellationToken); var members = Insert(destination.Members, declaration, options, availableIndices); return(ConditionallyAddFormattingAnnotationTo( destination.WithMembers(members), members)); }
private static AccessorListSyntax?GenerateAccessorList( IPropertySymbol property, CodeGenerationDestination destination, CSharpCodeGenerationOptions options) { var setAccessorKind = property.SetMethod?.IsInitOnly == true ? SyntaxKind.InitAccessorDeclaration : SyntaxKind.SetAccessorDeclaration; var accessors = new[] { GenerateAccessorDeclaration(property, property.GetMethod, SyntaxKind.GetAccessorDeclaration, destination, options), GenerateAccessorDeclaration(property, property.SetMethod, setAccessorKind, destination, options), }; return(accessors[0] == null && accessors[1] == null ? null : SyntaxFactory.AccessorList(accessors.WhereNotNull().ToSyntaxList())); }
internal static ParameterSyntax GetParameter(IParameterSymbol p, CSharpCodeGenerationOptions options, bool isExplicit, bool isFirstParam, bool seenOptional) { var reusableSyntax = GetReuseableSyntaxNodeForSymbol <ParameterSyntax>(p, options); if (reusableSyntax != null) { return(reusableSyntax); } return(SyntaxFactory.Parameter(p.Name.ToIdentifierToken()) .WithAttributeLists(GenerateAttributes(p, isExplicit, options)) .WithModifiers(GenerateModifiers(p, isFirstParam)) .WithType(p.Type.GenerateTypeSyntax()) .WithDefault(GenerateEqualsValueClause(p, isExplicit, seenOptional))); }
internal static DestructorDeclarationSyntax GenerateDestructorDeclaration( IMethodSymbol destructor, CSharpCodeGenerationOptions options, CancellationToken cancellationToken) { var reusableSyntax = GetReuseableSyntaxNodeForSymbol <DestructorDeclarationSyntax>(destructor, options); if (reusableSyntax != null) { return(reusableSyntax); } var hasNoBody = !options.Context.GenerateMethodBodies; var declaration = SyntaxFactory.DestructorDeclaration( attributeLists: AttributeGenerator.GenerateAttributeLists(destructor.GetAttributes(), options), modifiers: default,
internal static TypeDeclarationSyntax AddConstructorTo( TypeDeclarationSyntax destination, IMethodSymbol constructor, CSharpCodeGenerationOptions options, IList <bool>?availableIndices, CancellationToken cancellationToken) { var constructorDeclaration = GenerateConstructorDeclaration(constructor, options, cancellationToken); // Generate after the last constructor, or after the last field, or at the start of the // type. var members = Insert(destination.Members, constructorDeclaration, options, availableIndices, after: LastConstructorOrField, before: FirstMember); return(AddMembersTo(destination, members, cancellationToken)); }