private ISymbol GenerateMember( ISymbol member, bool addUnsafe, CancellationToken cancellationToken) { var modifiers = DeclarationModifiers.None.WithIsOverride(true).WithIsUnsafe(addUnsafe); var accessibility = member.ComputeResultantAccessibility(_state.ClassType); if (member.Kind == SymbolKind.Method) { return(GenerateMethod((IMethodSymbol)member, modifiers, accessibility, cancellationToken)); } else if (member.Kind == SymbolKind.Property) { return(GenerateProperty((IPropertySymbol)member, modifiers, accessibility, cancellationToken)); } else if (member.Kind == SymbolKind.Event) { var @event = (IEventSymbol)member; return(CodeGenerationSymbolFactory.CreateEventSymbol( @event, accessibility: accessibility, modifiers: modifiers)); } return(null); }
private static ISymbol MakeAbstractVersion(ISymbol member) { if (member.IsAbstract) { return(member); } var modifier = DeclarationModifiers.From(member).WithIsAbstract(true); if (member is IMethodSymbol methodSymbol) { return(CodeGenerationSymbolFactory.CreateMethodSymbol(methodSymbol, modifiers: modifier)); } else if (member is IPropertySymbol propertySymbol) { return(CodeGenerationSymbolFactory.CreatePropertySymbol(propertySymbol, modifiers: modifier, getMethod: propertySymbol.GetMethod, setMethod: propertySymbol.SetMethod)); } else if (member is IEventSymbol eventSymbol) { return(CodeGenerationSymbolFactory.CreateEventSymbol(eventSymbol, modifiers: modifier)); } else { throw ExceptionUtilities.UnexpectedValue(member); } }
internal static async Task TestAddEventAsync( string initial, string expected, string name = "E", IList <AttributeData> attributes = null, Accessibility accessibility = Accessibility.Public, DeclarationModifiers modifiers = default(DeclarationModifiers), IList <Func <SemanticModel, IParameterSymbol> > parameters = null, Type type = null, IEventSymbol explicitInterfaceSymbol = null, IMethodSymbol addMethod = null, IMethodSymbol removeMethod = null, IMethodSymbol raiseMethod = null, CodeGenerationOptions codeGenerationOptions = default(CodeGenerationOptions), bool compareTokens = true) { using (var context = await TestContext.CreateAsync(initial, expected, compareTokens)) { type = type ?? typeof(Action); var parameterSymbols = GetParameterSymbols(parameters, context); var typeSymbol = GetTypeSymbol(type)(context.SemanticModel); var @event = CodeGenerationSymbolFactory.CreateEventSymbol( attributes, accessibility, modifiers, typeSymbol, explicitInterfaceSymbol, name, addMethod, removeMethod, raiseMethod); context.Result = await context.Service.AddEventAsync(context.Solution, (INamedTypeSymbol)context.GetDestination(), @event, codeGenerationOptions); } }
internal static async Task TestAddEventAsync( string initial, string expected, string name = "E", ImmutableArray <AttributeData> attributes = default(ImmutableArray <AttributeData>), Accessibility accessibility = Accessibility.Public, Editing.DeclarationModifiers modifiers = default(Editing.DeclarationModifiers), ImmutableArray <Func <SemanticModel, IParameterSymbol> > parameters = default(ImmutableArray <Func <SemanticModel, IParameterSymbol> >), Type type = null, Func <SemanticModel, ImmutableArray <IEventSymbol> > getExplicitInterfaceImplementations = null, IMethodSymbol addMethod = null, IMethodSymbol removeMethod = null, IMethodSymbol raiseMethod = null, CodeGenerationOptions codeGenerationOptions = default(CodeGenerationOptions), bool ignoreTrivia = true) { using (var context = await TestContext.CreateAsync(initial, expected, ignoreTrivia)) { type = type ?? typeof(Action); var parameterSymbols = GetParameterSymbols(parameters, context); var typeSymbol = GetTypeSymbol(type)(context.SemanticModel); var @event = CodeGenerationSymbolFactory.CreateEventSymbol( attributes, accessibility, modifiers, typeSymbol, getExplicitInterfaceImplementations?.Invoke(context.SemanticModel) ?? default, name, addMethod, removeMethod, raiseMethod); context.Result = await context.Service.AddEventAsync(context.Solution, (INamedTypeSymbol)context.GetDestination(), @event, codeGenerationOptions); } }
private IList <ISymbol> CreateInterfaceMembers(IEnumerable <ISymbol> includedMembers) { var interfaceMembers = new List <ISymbol>(); foreach (var member in includedMembers) { switch (member.Kind) { case SymbolKind.Event: var @event = member as IEventSymbol; interfaceMembers.Add(CodeGenerationSymbolFactory.CreateEventSymbol( attributes: SpecializedCollections.EmptyList <AttributeData>(), accessibility: Accessibility.Public, modifiers: new DeclarationModifiers(isAbstract: true), type: @event.Type, explicitInterfaceSymbol: null, name: @event.Name)); break; case SymbolKind.Method: var method = member as IMethodSymbol; interfaceMembers.Add(CodeGenerationSymbolFactory.CreateMethodSymbol( attributes: SpecializedCollections.EmptyList <AttributeData>(), accessibility: Accessibility.Public, modifiers: new DeclarationModifiers(isAbstract: true, isUnsafe: method.IsUnsafe()), returnType: method.ReturnType, returnsByRef: method.ReturnsByRef, explicitInterfaceSymbol: null, name: method.Name, typeParameters: method.TypeParameters, parameters: method.Parameters)); break; case SymbolKind.Property: var property = member as IPropertySymbol; interfaceMembers.Add(CodeGenerationSymbolFactory.CreatePropertySymbol( attributes: SpecializedCollections.EmptyList <AttributeData>(), accessibility: Accessibility.Public, modifiers: new DeclarationModifiers(isAbstract: true, isUnsafe: property.IsUnsafe()), type: property.Type, returnsByRef: property.ReturnsByRef, explicitInterfaceSymbol: null, name: property.Name, parameters: property.Parameters, getMethod: property.GetMethod == null ? null : (property.GetMethod.DeclaredAccessibility == Accessibility.Public ? property.GetMethod : null), setMethod: property.SetMethod == null ? null : (property.SetMethod.DeclaredAccessibility == Accessibility.Public ? property.SetMethod : null), isIndexer: property.IsIndexer)); break; default: Debug.Assert(false, string.Format(FeaturesResources.Unexpected_interface_member_kind_colon_0, member.Kind.ToString())); break; } } return(interfaceMembers); }
internal static IEventSymbol GeneratePropertyChangedEvent(Compilation compilation) { var propertyChangedEventHandlerType = compilation.GetTypeByMetadataName("System.ComponentModel.PropertyChangedEventHandler"); return(CodeGenerationSymbolFactory.CreateEventSymbol( attributes: null, accessibility: Microsoft.CodeAnalysis.Accessibility.Public, modifiers: new SymbolModifiers(), type: propertyChangedEventHandlerType, explicitInterfaceSymbol: null, name: "PropertyChanged")); }
public static IEventSymbol OverrideEvent( this SyntaxGenerator codeFactory, IEventSymbol overriddenEvent, DeclarationModifiers modifiers, INamedTypeSymbol newContainingType) { return(CodeGenerationSymbolFactory.CreateEventSymbol( overriddenEvent, attributes: default(ImmutableArray <AttributeData>), accessibility: overriddenEvent.ComputeResultantAccessibility(newContainingType), modifiers: modifiers, explicitInterfaceImplementations: default,
private ISymbol GenerateMember( Compilation compilation, ISymbol member, string memberName, bool generateInvisibly, bool generateAbstractly, bool addNew, bool addUnsafe, CancellationToken cancellationToken) { var factory = this.Document.GetLanguageService <SyntaxGenerator>(); var modifiers = new DeclarationModifiers(isAbstract: generateAbstractly, isNew: addNew, isUnsafe: addUnsafe); var useExplicitInterfaceSymbol = generateInvisibly || !Service.CanImplementImplicitly; var accessibility = member.Name == memberName || generateAbstractly ? Accessibility.Public : Accessibility.Private; if (member.Kind == SymbolKind.Method) { var method = (IMethodSymbol)member; return(GenerateMethod(compilation, method, accessibility, modifiers, generateAbstractly, useExplicitInterfaceSymbol, memberName, cancellationToken)); } else if (member.Kind == SymbolKind.Property) { var property = (IPropertySymbol)member; return(GenerateProperty(compilation, property, accessibility, modifiers, generateAbstractly, useExplicitInterfaceSymbol, memberName, cancellationToken)); } else if (member.Kind == SymbolKind.Event) { var @event = (IEventSymbol)member; var accessor = CodeGenerationSymbolFactory.CreateAccessorSymbol( attributes: null, accessibility: Accessibility.NotApplicable, statements: factory.CreateThrowNotImplementedStatementBlock(compilation)); return(CodeGenerationSymbolFactory.CreateEventSymbol( @event, accessibility: accessibility, modifiers: modifiers, explicitInterfaceSymbol: useExplicitInterfaceSymbol ? @event : null, name: memberName, addMethod: generateInvisibly ? accessor : null, removeMethod: generateInvisibly ? accessor : null)); } return(null); }
public static IEventSymbol OverrideEvent( this SyntaxGenerator codeFactory, IEventSymbol overriddenEvent, DeclarationModifiers modifiers, INamedTypeSymbol newContainingType) { return(CodeGenerationSymbolFactory.CreateEventSymbol( overriddenEvent, attributes: null, accessibility: overriddenEvent.ComputeResultantAccessibility(newContainingType), modifiers: modifiers, explicitInterfaceSymbol: null, name: overriddenEvent.Name)); }
private static void ChangeEventToPublicAndNonStatic( ICodeGenerationService codeGenerationService, DocumentEditor editor, IEventSymbol eventSymbol, SyntaxNode eventDeclaration, DeclarationModifiers modifiers ) { var declaration = editor.Generator.GetDeclaration(eventDeclaration); var isEventHasExplicitAddOrRemoveMethod = (eventSymbol.AddMethod != null && !eventSymbol.AddMethod.IsImplicitlyDeclared) || ( eventSymbol.RemoveMethod != null && !eventSymbol.RemoveMethod.IsImplicitlyDeclared ); // There are three situations here: // 1. Single Event. // 2. Several events exist in one declaration. // 3. Event has add or remove method(user declared). // For situation 1, declaration is EventFieldDeclaration, eventDeclaration is variableDeclaration. // For situation 2, declaration and eventDeclaration are both EventDeclaration, which are same. // For situation 3, it is same as situation 2, but has add or remove method. if (declaration.Equals(eventDeclaration) && !isEventHasExplicitAddOrRemoveMethod) { // Several events are declared in same line var publicAndNonStaticSymbol = CodeGenerationSymbolFactory.CreateEventSymbol( eventSymbol, accessibility: Accessibility.Public, modifiers: modifiers ); var options = new CodeGenerationOptions(generateMethodBodies: false); var publicAndNonStaticSyntax = codeGenerationService.CreateEventDeclaration( publicAndNonStaticSymbol, destination: CodeGenerationDestination.ClassType, options: options ); // Insert a new declaration and remove the original declaration editor.InsertAfter(declaration, publicAndNonStaticSyntax); editor.RemoveNode(eventDeclaration); } else { // Handle both single event and event has add or remove method editor.SetAccessibility(declaration, Accessibility.Public); editor.SetModifiers(declaration, modifiers); } }
private ISymbol GenerateMember( ISymbol member, bool addUnsafe, ImplementTypePropertyGenerationBehavior propertyGenerationBehavior, CancellationToken cancellationToken) { var modifiers = new DeclarationModifiers(isOverride: true, isUnsafe: addUnsafe); var accessibility = member.ComputeResultantAccessibility(_state.ClassType); return(member switch { IMethodSymbol method => GenerateMethod(method, modifiers, accessibility, cancellationToken), IPropertySymbol property => GenerateProperty(property, modifiers, accessibility, propertyGenerationBehavior), IEventSymbol @event => CodeGenerationSymbolFactory.CreateEventSymbol( @event, accessibility: accessibility, modifiers: modifiers), _ => null, });
protected SyntaxNode CreateEventDeclaration(SyntaxNode containerNode, string name, EnvDTE.vsCMAccess access, ITypeSymbol type, bool createPropertyStyleEvent) { var destination = CodeModelService.GetDestination(containerNode); IMethodSymbol addMethod = null; IMethodSymbol removeMethod = null; if (createPropertyStyleEvent) { addMethod = CodeGenerationSymbolFactory.CreateMethodSymbol( attributes: default(ImmutableArray <AttributeData>), accessibility: Accessibility.NotApplicable, modifiers: new DeclarationModifiers(), returnType: null, returnsByRef: false, explicitInterfaceSymbol: null, name: "add_" + name, typeParameters: default(ImmutableArray <ITypeParameterSymbol>), parameters: default(ImmutableArray <IParameterSymbol>)); removeMethod = CodeGenerationSymbolFactory.CreateMethodSymbol( attributes: default(ImmutableArray <AttributeData>), accessibility: Accessibility.NotApplicable, modifiers: new DeclarationModifiers(), returnType: null, returnsByRef: false, explicitInterfaceSymbol: null, name: "remove_" + name, typeParameters: default(ImmutableArray <ITypeParameterSymbol>), parameters: default(ImmutableArray <IParameterSymbol>)); } var newEventSymbol = CodeGenerationSymbolFactory.CreateEventSymbol( attributes: default(ImmutableArray <AttributeData>), accessibility: CodeModelService.GetAccessibility(access, SymbolKind.Event, destination), modifiers: new DeclarationModifiers(), type: type, explicitInterfaceSymbol: null, name: name, addMethod: addMethod, removeMethod: removeMethod); return(CodeGenerationService.CreateEventDeclaration( newEventSymbol, destination, options: GetCodeGenerationOptions(access, containerNode.SyntaxTree.Options))); }