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());
}
