internal static IPropertySymbol CreatePropertySymbol( INamedTypeSymbol containingType, IList <AttributeData> attributes, Accessibility accessibility, SymbolModifiers modifiers, ITypeSymbol type, IPropertySymbol explicitInterfaceSymbol, string name, IList <IParameterSymbol> parameters, IMethodSymbol getMethod, IMethodSymbol setMethod, bool isIndexer = false, SyntaxNode initializer = null) { var result = new CodeGenerationPropertySymbol( containingType, attributes, accessibility, modifiers, type, explicitInterfaceSymbol, name, isIndexer, parameters, getMethod, setMethod); CodeGenerationPropertyInfo.Attach(result, modifiers.IsNew, modifiers.IsUnsafe, initializer); return(result); }
/// <summary> /// Creates a struct declaration. /// </summary> public abstract SyntaxNode StructDeclaration( string name, IEnumerable <string> typeParameters = null, Accessibility accessibility = Accessibility.NotApplicable, SymbolModifiers modifiers = default(SymbolModifiers), IEnumerable <SyntaxNode> interfaceTypes = null, IEnumerable <SyntaxNode> members = null);
/// <summary> /// Creates a property declaration. /// </summary> public abstract SyntaxNode PropertyDeclaration( string name, SyntaxNode type, Accessibility accessibility = Accessibility.NotApplicable, SymbolModifiers modifiers = default(SymbolModifiers), IEnumerable <SyntaxNode> getterStatements = null, IEnumerable <SyntaxNode> setterStatements = null);
/// <summary> /// Creates an indexer declaration. /// </summary> public abstract SyntaxNode IndexerDeclaration( IEnumerable <SyntaxNode> parameters, SyntaxNode type, Accessibility accessibility = Accessibility.NotApplicable, SymbolModifiers modifiers = default(SymbolModifiers), IEnumerable <SyntaxNode> getterStatements = null, IEnumerable <SyntaxNode> setterStatements = null);
/// <summary> /// Creates a constructor declaration. /// </summary> public abstract SyntaxNode ConstructorDeclaration( string containingTypeName = null, IEnumerable <SyntaxNode> parameters = null, Accessibility accessibility = Accessibility.NotApplicable, SymbolModifiers modifiers = default(SymbolModifiers), IEnumerable <SyntaxNode> baseConstructorArguments = null, IEnumerable <SyntaxNode> statements = null);
public CodeGenerationNamedTypeSymbol( INamedTypeSymbol containingType, IList <AttributeData> attributes, Accessibility declaredAccessibility, SymbolModifiers modifiers, TypeKind typeKind, string name, IList <ITypeParameterSymbol> typeParameters, INamedTypeSymbol baseType, IList <INamedTypeSymbol> interfaces, SpecialType specialType, IList <ISymbol> members, IList <CodeGenerationAbstractNamedTypeSymbol> typeMembers, INamedTypeSymbol enumUnderlyingType) : base(containingType, attributes, declaredAccessibility, modifiers, name, specialType, typeMembers) { this.typeKind = typeKind; this.typeParameters = typeParameters ?? SpecializedCollections.EmptyList <ITypeParameterSymbol>(); this.baseType = baseType; this.interfaces = interfaces ?? SpecializedCollections.EmptyList <INamedTypeSymbol>(); this.members = members ?? SpecializedCollections.EmptyList <ISymbol>(); this.enumUnderlyingType = enumUnderlyingType; this.OriginalDefinition = this; }
internal static IPropertySymbol CreatePropertySymbol( INamedTypeSymbol containingType, IList<AttributeData> attributes, Accessibility accessibility, SymbolModifiers modifiers, ITypeSymbol type, IPropertySymbol explicitInterfaceSymbol, string name, IList<IParameterSymbol> parameters, IMethodSymbol getMethod, IMethodSymbol setMethod, bool isIndexer = false, SyntaxNode initializer = null) { var result = new CodeGenerationPropertySymbol( containingType, attributes, accessibility, modifiers, type, explicitInterfaceSymbol, name, isIndexer, parameters, getMethod, setMethod); CodeGenerationPropertyInfo.Attach(result, modifiers.IsNew, modifiers.IsUnsafe, initializer); return result; }
public CodeGenerationNamedTypeSymbol( INamedTypeSymbol containingType, IList<AttributeData> attributes, Accessibility declaredAccessibility, SymbolModifiers modifiers, TypeKind typeKind, string name, IList<ITypeParameterSymbol> typeParameters, INamedTypeSymbol baseType, IList<INamedTypeSymbol> interfaces, SpecialType specialType, IList<ISymbol> members, IList<CodeGenerationAbstractNamedTypeSymbol> typeMembers, INamedTypeSymbol enumUnderlyingType) : base(containingType, attributes, declaredAccessibility, modifiers, name, specialType, typeMembers) { this.typeKind = typeKind; this.typeParameters = typeParameters ?? SpecializedCollections.EmptyList<ITypeParameterSymbol>(); this.baseType = baseType; this.interfaces = interfaces ?? SpecializedCollections.EmptyList<INamedTypeSymbol>(); this.members = members ?? SpecializedCollections.EmptyList<ISymbol>(); this.enumUnderlyingType = enumUnderlyingType; this.OriginalDefinition = this; }
/// <summary> /// Creates a method declaration. /// </summary> public abstract SyntaxNode MethodDeclaration( string name, IEnumerable <SyntaxNode> parameters = null, IEnumerable <string> typeParameters = null, SyntaxNode returnType = null, Accessibility accessibility = Accessibility.NotApplicable, SymbolModifiers modifiers = default(SymbolModifiers), IEnumerable <SyntaxNode> statements = null);
/// <summary> /// Creates a method declaration. /// </summary> public abstract SyntaxNode MethodDeclaration( string name, IEnumerable<SyntaxNode> parameters = null, IEnumerable<string> typeParameters = null, SyntaxNode returnType = null, Accessibility accessibility = Accessibility.NotApplicable, SymbolModifiers modifiers = default(SymbolModifiers), IEnumerable<SyntaxNode> statements = null);
protected CodeGenerationNamespaceOrTypeSymbol( INamedTypeSymbol containingType, IList <AttributeData> attributes, Accessibility declaredAccessibility, SymbolModifiers modifiers, string name) : base(containingType, attributes, declaredAccessibility, modifiers, name) { }
/// <summary> /// Creates a field declaration matching an existing field symbol. /// </summary> public SyntaxNode FieldDeclaration(IFieldSymbol field, SyntaxNode initializer = null) { return(FieldDeclaration( field.Name, TypeExpression(field.Type), field.DeclaredAccessibility, SymbolModifiers.From(field), initializer)); }
protected CodeGenerationNamespaceOrTypeSymbol( INamedTypeSymbol containingType, IList<AttributeData> attributes, Accessibility declaredAccessibility, SymbolModifiers modifiers, string name) : base(containingType, attributes, declaredAccessibility, modifiers, name) { }
/// <summary> /// Creates a property declaration using an existing property symbol as a signature. /// </summary> public SyntaxNode PropertyDeclaration(IPropertySymbol property, IEnumerable <SyntaxNode> getterStatements = null, IEnumerable <SyntaxNode> setterStatements = null) { return(PropertyDeclaration( property.Name, TypeExpression(property.Type), property.DeclaredAccessibility, SymbolModifiers.From(property), getterStatements, setterStatements)); }
/// <summary> /// Creates an indexer declaration matching an existing indexer symbol. /// </summary> public SyntaxNode IndexerDeclaration(IPropertySymbol indexer, IEnumerable <SyntaxNode> getterStatements = null, IEnumerable <SyntaxNode> setterStatements = null) { return(IndexerDeclaration( indexer.Parameters.Select(p => this.ParameterDeclaration(p)), TypeExpression(indexer.Type), indexer.DeclaredAccessibility, SymbolModifiers.From(indexer), getterStatements, setterStatements)); }
protected CodeGenerationTypeSymbol( INamedTypeSymbol containingType, IList <AttributeData> attributes, Accessibility declaredAccessibility, SymbolModifiers modifiers, string name, SpecialType specialType) : base(containingType, attributes, declaredAccessibility, modifiers, name) { this.SpecialType = specialType; }
protected CodeGenerationTypeSymbol( INamedTypeSymbol containingType, IList<AttributeData> attributes, Accessibility declaredAccessibility, SymbolModifiers modifiers, string name, SpecialType specialType) : base(containingType, attributes, declaredAccessibility, modifiers, name) { this.SpecialType = specialType; }
protected CodeGenerationAbstractMethodSymbol( INamedTypeSymbol containingType, IList <AttributeData> attributes, Accessibility declaredAccessibility, SymbolModifiers modifiers, string name, IList <AttributeData> returnTypeAttributes) : base(containingType, attributes, declaredAccessibility, modifiers, name) { this.returnTypeAttributes = returnTypeAttributes.AsImmutableOrEmpty(); }
protected CodeGenerationSymbol( INamedTypeSymbol containingType, IList <AttributeData> attributes, Accessibility declaredAccessibility, SymbolModifiers modifiers, string name) { this.ContainingType = containingType; this.attributes = attributes.AsImmutableOrEmpty(); this.DeclaredAccessibility = declaredAccessibility; this.Modifiers = modifiers; this.Name = name; }
/// <summary> /// Create a constructor declaration using /// </summary> public SyntaxNode ConstructorDeclaration( IMethodSymbol constructorMethod, IEnumerable <SyntaxNode> baseConstructorArguments = null, IEnumerable <SyntaxNode> statements = null) { return(ConstructorDeclaration( constructorMethod.ContainingType != null ? constructorMethod.ContainingType.Name : "New", constructorMethod.Parameters.Select(p => ParameterDeclaration(p)), constructorMethod.DeclaredAccessibility, SymbolModifiers.From(constructorMethod), baseConstructorArguments, statements)); }
/// <summary> /// Creates a property symbol that can be used to describe a property declaration. /// </summary> public static IPropertySymbol CreatePropertySymbol(IList<AttributeData> attributes, Accessibility accessibility, SymbolModifiers modifiers, ITypeSymbol type, IPropertySymbol explicitInterfaceSymbol, string name, IList<IParameterSymbol> parameters, IMethodSymbol getMethod, IMethodSymbol setMethod, bool isIndexer = false) { return CreatePropertySymbol( containingType: null, attributes: attributes, accessibility: accessibility, modifiers: modifiers, type: type, explicitInterfaceSymbol: explicitInterfaceSymbol, name: name, parameters: parameters, getMethod: getMethod, setMethod: setMethod, isIndexer: isIndexer); }
public CodeGenerationFieldSymbol( INamedTypeSymbol containingType, IList <AttributeData> attributes, Accessibility accessibility, SymbolModifiers modifiers, ITypeSymbol type, string name, bool hasConstantValue, object constantValue) : base(containingType, attributes, accessibility, modifiers, name) { this.Type = type; this.HasConstantValue = hasConstantValue; this.ConstantValue = constantValue; }
protected CodeGenerationAbstractNamedTypeSymbol( INamedTypeSymbol containingType, IList <AttributeData> attributes, Accessibility declaredAccessibility, SymbolModifiers modifiers, string name, SpecialType specialType, IList <CodeGenerationAbstractNamedTypeSymbol> typeMembers) : base(containingType, attributes, declaredAccessibility, modifiers, name, specialType) { this.TypeMembers = typeMembers; foreach (var member in typeMembers) { member.ContainingType = this; } }
/// <summary> /// Creates a method declaration matching an existing method symbol. /// </summary> public SyntaxNode MethodDeclaration(IMethodSymbol method, IEnumerable <SyntaxNode> statements = null) { var decl = MethodDeclaration( method.Name, parameters: method.Parameters.Select(p => ParameterDeclaration(p)), returnType: TypeExpression(method.ReturnType), accessibility: method.DeclaredAccessibility, modifiers: SymbolModifiers.From(method), statements: statements); if (method.TypeParameters.Length > 0) { decl = this.WithTypeParametersAndConstraints(decl, method.TypeParameters); } return(decl); }
public CodeGenerationConstructorSymbol( INamedTypeSymbol containingType, IList <AttributeData> attributes, Accessibility accessibility, SymbolModifiers modifiers, IList <IParameterSymbol> parameters) : base(containingType, attributes, accessibility, modifiers, returnType: null, explicitInterfaceSymbolOpt: null, name: string.Empty, typeParameters: SpecializedCollections.EmptyList <ITypeParameterSymbol>(), parameters: parameters, returnTypeAttributes: SpecializedCollections.EmptyList <AttributeData>()) { }
public CodeGenerationConstructorSymbol( INamedTypeSymbol containingType, IList<AttributeData> attributes, Accessibility accessibility, SymbolModifiers modifiers, IList<IParameterSymbol> parameters) : base(containingType, attributes, accessibility, modifiers, returnType: null, explicitInterfaceSymbolOpt: null, name: string.Empty, typeParameters: SpecializedCollections.EmptyList<ITypeParameterSymbol>(), parameters: parameters, returnTypeAttributes: SpecializedCollections.EmptyList<AttributeData>()) { }
public CodeGenerationOperatorSymbol( INamedTypeSymbol containingType, IList <AttributeData> attributes, Accessibility accessibility, SymbolModifiers modifiers, ITypeSymbol returnType, CodeGenerationOperatorKind operatorKind, IList <IParameterSymbol> parameters, IList <AttributeData> returnTypeAttributes) : base(containingType, attributes, accessibility, modifiers, returnType: returnType, explicitInterfaceSymbolOpt: null, name: GetMetadataName(operatorKind), typeParameters: SpecializedCollections.EmptyList <ITypeParameterSymbol>(), parameters: parameters, returnTypeAttributes: returnTypeAttributes) { }
public CodeGenerationOperatorSymbol( INamedTypeSymbol containingType, IList<AttributeData> attributes, Accessibility accessibility, SymbolModifiers modifiers, ITypeSymbol returnType, CodeGenerationOperatorKind operatorKind, IList<IParameterSymbol> parameters, IList<AttributeData> returnTypeAttributes) : base(containingType, attributes, accessibility, modifiers, returnType: returnType, explicitInterfaceSymbolOpt: null, name: GetMetadataName(operatorKind), typeParameters: SpecializedCollections.EmptyList<ITypeParameterSymbol>(), parameters: parameters, returnTypeAttributes: returnTypeAttributes) { }
public CodeGenerationMethodSymbol( INamedTypeSymbol containingType, IList<AttributeData> attributes, Accessibility declaredAccessibility, SymbolModifiers modifiers, ITypeSymbol returnType, IMethodSymbol explicitInterfaceSymbolOpt, string name, IList<ITypeParameterSymbol> typeParameters, IList<IParameterSymbol> parameters, IList<AttributeData> returnTypeAttributes) : base(containingType, attributes, declaredAccessibility, modifiers, name, returnTypeAttributes) { this.returnType = returnType; this.typeParameters = typeParameters.AsImmutableOrEmpty(); this.parameters = parameters.AsImmutableOrEmpty(); this.explicitInterfaceImplementations = explicitInterfaceSymbolOpt == null ? ImmutableArray.Create<IMethodSymbol>() : ImmutableArray.Create(explicitInterfaceSymbolOpt); this.OriginalDefinition = this; }
public CodeGenerationConversionSymbol( INamedTypeSymbol containingType, IList <AttributeData> attributes, Accessibility declaredAccessibility, SymbolModifiers modifiers, ITypeSymbol toType, IParameterSymbol fromType, bool isImplicit, IList <AttributeData> toTypeAttributes) : base(containingType, attributes, declaredAccessibility, modifiers, returnType: toType, explicitInterfaceSymbolOpt: null, name: isImplicit ? WellKnownMemberNames.ImplicitConversionName : WellKnownMemberNames.ExplicitConversionName, typeParameters: SpecializedCollections.EmptyList <ITypeParameterSymbol>(), parameters: new List <IParameterSymbol>(SpecializedCollections.SingletonEnumerable(fromType)), returnTypeAttributes: toTypeAttributes) { }
public CodeGenerationConversionSymbol( INamedTypeSymbol containingType, IList<AttributeData> attributes, Accessibility declaredAccessibility, SymbolModifiers modifiers, ITypeSymbol toType, IParameterSymbol fromType, bool isImplicit, IList<AttributeData> toTypeAttributes) : base(containingType, attributes, declaredAccessibility, modifiers, returnType: toType, explicitInterfaceSymbolOpt: null, name: isImplicit ? WellKnownMemberNames.ImplicitConversionName : WellKnownMemberNames.ExplicitConversionName, typeParameters: SpecializedCollections.EmptyList<ITypeParameterSymbol>(), parameters: new List<IParameterSymbol>(SpecializedCollections.SingletonEnumerable(fromType)), returnTypeAttributes: toTypeAttributes) { }
public CodeGenerationEventSymbol( INamedTypeSymbol containingType, IList <AttributeData> attributes, Accessibility declaredAccessibility, SymbolModifiers modifiers, ITypeSymbol type, IEventSymbol explicitInterfaceSymbolOpt, string name, IMethodSymbol addMethod, IMethodSymbol removeMethod, IMethodSymbol raiseMethod, IList <IParameterSymbol> parameterList) : base(containingType, attributes, declaredAccessibility, modifiers, name) { this.Type = type; this.ExplicitInterfaceImplementations = explicitInterfaceSymbolOpt == null ? ImmutableArray.Create <IEventSymbol>() : ImmutableArray.Create(explicitInterfaceSymbolOpt); this.AddMethod = addMethod; this.RemoveMethod = removeMethod; this.RaiseMethod = raiseMethod; this.ParameterList = parameterList; }
public CodeGenerationPropertySymbol( INamedTypeSymbol containingType, IList <AttributeData> attributes, Accessibility declaredAccessibility, SymbolModifiers modifiers, ITypeSymbol type, IPropertySymbol explicitInterfaceSymbolOpt, string name, bool isIndexer, IList <IParameterSymbol> parametersOpt, IMethodSymbol getMethod, IMethodSymbol setMethod) : base(containingType, attributes, declaredAccessibility, modifiers, name) { this.Type = type; this.IsIndexer = isIndexer; this.Parameters = parametersOpt.AsImmutableOrEmpty(); this.ExplicitInterfaceImplementations = explicitInterfaceSymbolOpt == null ? ImmutableArray.Create <IPropertySymbol>() : ImmutableArray.Create(explicitInterfaceSymbolOpt); this.GetMethod = getMethod; this.SetMethod = setMethod; }
/// <summary> /// Creates an event symbol that can be used to describe an event declaration. /// </summary> public static IEventSymbol CreateEventSymbol(IList<AttributeData> attributes, Accessibility accessibility, SymbolModifiers modifiers, ITypeSymbol type, IEventSymbol explicitInterfaceSymbol, string name, IMethodSymbol addMethod = null, IMethodSymbol removeMethod = null, IMethodSymbol raiseMethod = null, IList<IParameterSymbol> parameterList = null) { var result = new CodeGenerationEventSymbol(null, attributes, accessibility, modifiers, type, explicitInterfaceSymbol, name, addMethod, removeMethod, raiseMethod, parameterList); CodeGenerationEventInfo.Attach(result, modifiers.IsUnsafe); return result; }
internal static IPropertySymbol CreatePropertySymbol( IPropertySymbol property, IList<AttributeData> attributes = null, Accessibility? accessibility = null, SymbolModifiers? modifiers = null, IPropertySymbol explicitInterfaceSymbol = null, string name = null, bool? isIndexer = null, IMethodSymbol getMethod = null, IMethodSymbol setMethod = null) { return CodeGenerationSymbolFactory.CreatePropertySymbol( attributes, accessibility ?? property.DeclaredAccessibility, modifiers ?? property.GetSymbolModifiers(), property.Type, explicitInterfaceSymbol, name ?? property.Name, property.Parameters, getMethod, setMethod, isIndexer ?? property.IsIndexer); }
/// <summary> /// Creates a property declaration. /// </summary> public abstract SyntaxNode PropertyDeclaration( string name, SyntaxNode type, Accessibility accessibility = Accessibility.NotApplicable, SymbolModifiers modifiers = default(SymbolModifiers), IEnumerable<SyntaxNode> getterStatements = null, IEnumerable<SyntaxNode> setterStatements = null);
/// <summary> /// Creates a method symbol that can be used to describe a conversion declaration. /// </summary> public static IMethodSymbol CreateConversionSymbol(IList<AttributeData> attributes, Accessibility accessibility, SymbolModifiers modifiers, ITypeSymbol toType, IParameterSymbol fromType, bool isImplicit = false, IList<SyntaxNode> statements = null, IList<AttributeData> toTypeAttributes = null) { var result = new CodeGenerationConversionSymbol(null, attributes, accessibility, modifiers, toType, fromType, isImplicit, toTypeAttributes); CodeGenerationMethodInfo.Attach(result, modifiers.IsNew, modifiers.IsUnsafe, modifiers.IsPartial, modifiers.IsAsync, statements, handlesExpressions: null); return result; }
/// <summary> /// Creates a method type symbol that can be used to describe a delegate type declaration. /// </summary> public static INamedTypeSymbol CreateDelegateTypeSymbol(IList<AttributeData> attributes, Accessibility accessibility, SymbolModifiers modifiers, ITypeSymbol returnType, string name, IList<ITypeParameterSymbol> typeParameters = null, IList<IParameterSymbol> parameters = null) { var invokeMethod = CreateMethodSymbol( attributes: null, accessibility: Accessibility.Public, modifiers: new SymbolModifiers(), returnType: returnType, explicitInterfaceSymbol: null, name: "Invoke", typeParameters: null, parameters: parameters); return new CodeGenerationNamedTypeSymbol( containingType: null, attributes: attributes, declaredAccessibility: accessibility, modifiers: modifiers, typeKind: TypeKind.Delegate, name: name, typeParameters: typeParameters, baseType: null, interfaces: null, specialType: SpecialType.None, members: new[] { invokeMethod }, typeMembers: SpecializedCollections.EmptyList<CodeGenerationAbstractNamedTypeSymbol>(), enumUnderlyingType: null); }
/// <summary> /// Creates a declaration matching an existing symbol. /// </summary> public SyntaxNode Declaration(ISymbol symbol) { switch (symbol.Kind) { case SymbolKind.Field: return(FieldDeclaration((IFieldSymbol)symbol)); case SymbolKind.Property: var property = (IPropertySymbol)symbol; if (property.IsIndexer) { return(IndexerDeclaration(property)); } else { return(PropertyDeclaration(property)); } case SymbolKind.Method: var method = (IMethodSymbol)symbol; switch (method.MethodKind) { case MethodKind.Constructor: case MethodKind.SharedConstructor: return(ConstructorDeclaration(method)); case MethodKind.Ordinary: return(MethodDeclaration(method)); } break; case SymbolKind.Parameter: return(ParameterDeclaration((IParameterSymbol)symbol)); case SymbolKind.NamedType: var type = (INamedTypeSymbol)symbol; SyntaxNode declaration = null; switch (type.TypeKind) { case TypeKind.Class: declaration = ClassDeclaration( type.Name, accessibility: type.DeclaredAccessibility, modifiers: SymbolModifiers.From(type), baseType: TypeExpression(type.BaseType), interfaceTypes: type.Interfaces != null ? type.Interfaces.Select(i => TypeExpression(i)) : null, members: type.GetMembers().Select(m => Declaration(m))); break; case TypeKind.Struct: declaration = StructDeclaration( type.Name, accessibility: type.DeclaredAccessibility, modifiers: SymbolModifiers.From(type), interfaceTypes: type.Interfaces != null ? type.Interfaces.Select(i => TypeExpression(i)) : null, members: type.GetMembers().Select(m => Declaration(m))); break; case TypeKind.Interface: declaration = InterfaceDeclaration( type.Name, accessibility: type.DeclaredAccessibility, interfaceTypes: type.Interfaces != null ? type.Interfaces.Select(i => TypeExpression(i)) : null, members: type.GetMembers().Select(m => Declaration(m))); break; case TypeKind.Enum: declaration = EnumDeclaration( type.Name, accessibility: type.DeclaredAccessibility, members: type.GetMembers().Select(m => Declaration(m))); break; } if (declaration != null) { return(WithTypeParametersAndConstraints(declaration, type.TypeParameters)); } break; } throw new ArgumentException("Symbol cannot be converted to a declaration"); }
internal static IMethodSymbol CreateMethodSymbol( IMethodSymbol method, IList<AttributeData> attributes = null, Accessibility? accessibility = null, SymbolModifiers? modifiers = null, IMethodSymbol explicitInterfaceSymbol = null, string name = null, IList<SyntaxNode> statements = null) { return CodeGenerationSymbolFactory.CreateMethodSymbol( attributes, accessibility ?? method.DeclaredAccessibility, modifiers ?? method.GetSymbolModifiers(), method.ReturnType, explicitInterfaceSymbol, name ?? method.Name, method.TypeParameters, method.Parameters, statements, returnTypeAttributes: method.GetReturnTypeAttributes()); }
internal static IEventSymbol CreateEventSymbol( IEventSymbol @event, IList<AttributeData> attributes = null, Accessibility? accessibility = null, SymbolModifiers? modifiers = null, IEventSymbol explicitInterfaceSymbol = null, string name = null, IMethodSymbol addMethod = null, IMethodSymbol removeMethod = null) { return CodeGenerationSymbolFactory.CreateEventSymbol( attributes, accessibility ?? @event.DeclaredAccessibility, modifiers ?? @event.GetSymbolModifiers(), @event.Type, explicitInterfaceSymbol, name ?? @event.Name, addMethod, removeMethod); }
/// <summary> /// Creates a field symbol that can be used to describe a field declaration. /// </summary> public static IFieldSymbol CreateFieldSymbol(IList<AttributeData> attributes, Accessibility accessibility, SymbolModifiers modifiers, ITypeSymbol type, string name, bool hasConstantValue = false, object constantValue = null, SyntaxNode initializer = null) { var result = new CodeGenerationFieldSymbol(null, attributes, accessibility, modifiers, type, name, hasConstantValue, constantValue); CodeGenerationFieldInfo.Attach(result, modifiers.IsUnsafe, modifiers.IsWithEvents, initializer); return result; }
/// <summary> /// Creates a method symbol that can be used to describe an operator declaration. /// </summary> public static IMethodSymbol CreateOperatorSymbol(IList<AttributeData> attributes, Accessibility accessibility, SymbolModifiers modifiers, ITypeSymbol returnType, CodeGenerationOperatorKind operatorKind, IList<IParameterSymbol> parameters, IList<SyntaxNode> statements = null, IList<AttributeData> returnTypeAttributes = null) { int expectedParameterCount = CodeGenerationOperatorSymbol.GetParameterCount(operatorKind); if (parameters.Count != expectedParameterCount) { var message = expectedParameterCount == 1 ? WorkspacesResources.InvalidParameterCountForUnaryOperator : WorkspacesResources.InvalidParameterCountForBinaryOperator; throw new ArgumentException(message, "parameters"); } var result = new CodeGenerationOperatorSymbol(null, attributes, accessibility, modifiers, returnType, operatorKind, parameters, returnTypeAttributes); CodeGenerationMethodInfo.Attach(result, modifiers.IsNew, modifiers.IsUnsafe, modifiers.IsPartial, modifiers.IsAsync, statements, handlesExpressions: null); return result; }
/// <summary> /// Creates a constructor symbol that can be used to describe a constructor declaration. /// </summary> public static IMethodSymbol CreateConstructorSymbol(IList<AttributeData> attributes, Accessibility accessibility, SymbolModifiers modifiers, string typeName, IList<IParameterSymbol> parameters, IList<SyntaxNode> statements = null, IList<SyntaxNode> baseConstructorArguments = null, IList<SyntaxNode> thisConstructorArguments = null) { var result = new CodeGenerationConstructorSymbol(null, attributes, accessibility, modifiers, parameters); CodeGenerationConstructorInfo.Attach(result, typeName, statements, baseConstructorArguments, thisConstructorArguments); return result; }
/// <summary> /// Creates a constructor declaration. /// </summary> public abstract SyntaxNode ConstructorDeclaration( string containingTypeName = null, IEnumerable<SyntaxNode> parameters = null, Accessibility accessibility = Accessibility.NotApplicable, SymbolModifiers modifiers = default(SymbolModifiers), IEnumerable<SyntaxNode> baseConstructorArguments = null, IEnumerable<SyntaxNode> statements = null);
/// <summary> /// Creates an indexer declaration. /// </summary> public abstract SyntaxNode IndexerDeclaration( IEnumerable<SyntaxNode> parameters, SyntaxNode type, Accessibility accessibility = Accessibility.NotApplicable, SymbolModifiers modifiers = default(SymbolModifiers), IEnumerable<SyntaxNode> getterStatements = null, IEnumerable<SyntaxNode> setterStatements = null);
public static IMethodSymbol OverrideMethod( this SyntaxGenerator codeFactory, IMethodSymbol overriddenMethod, SymbolModifiers modifiers, INamedTypeSymbol newContainingType, Document newDocument, CancellationToken cancellationToken) { // Abstract: Throw not implemented if (overriddenMethod.IsAbstract) { return CodeGenerationSymbolFactory.CreateMethodSymbol( overriddenMethod, accessibility: overriddenMethod.ComputeResultantAccessibility(newContainingType), modifiers: modifiers, statements: new[] { codeFactory.CreateThrowNotImplementStatement(newDocument.Project.GetCompilationAsync(cancellationToken).WaitAndGetResult(cancellationToken)) }); } else { // Otherwise, call the base method with the same parameters var typeParams = overriddenMethod.GetTypeArguments(); var body = codeFactory.InvocationExpression( codeFactory.MemberAccessExpression(codeFactory.BaseExpression(), typeParams.IsDefaultOrEmpty ? codeFactory.IdentifierName(overriddenMethod.Name) : codeFactory.GenericName(overriddenMethod.Name, typeParams)), codeFactory.CreateArguments(overriddenMethod.GetParameters())); return CodeGenerationSymbolFactory.CreateMethodSymbol( method: overriddenMethod, accessibility: overriddenMethod.ComputeResultantAccessibility(newContainingType), modifiers: modifiers, statements: ((IMethodSymbol)overriddenMethod).ReturnsVoid ? new SyntaxNode[] { codeFactory.ExpressionStatement(body) } : new SyntaxNode[] { codeFactory.ReturnStatement(body) }); } }
public static IEventSymbol OverrideEvent( this SyntaxGenerator codeFactory, IEventSymbol overriddenEvent, SymbolModifiers modifiers, INamedTypeSymbol newContainingType) { return CodeGenerationSymbolFactory.CreateEventSymbol( overriddenEvent, attributes: null, accessibility: overriddenEvent.ComputeResultantAccessibility(newContainingType), modifiers: modifiers, explicitInterfaceSymbol: null, name: overriddenEvent.Name); }
/// <summary> /// Creates a property symbol that can be used to describe a property declaration. /// </summary> public static IPropertySymbol CreatePropertySymbol(IList <AttributeData> attributes, Accessibility accessibility, SymbolModifiers modifiers, ITypeSymbol type, IPropertySymbol explicitInterfaceSymbol, string name, IList <IParameterSymbol> parameters, IMethodSymbol getMethod, IMethodSymbol setMethod, bool isIndexer = false) { return(CreatePropertySymbol( containingType: null, attributes: attributes, accessibility: accessibility, modifiers: modifiers, type: type, explicitInterfaceSymbol: explicitInterfaceSymbol, name: name, parameters: parameters, getMethod: getMethod, setMethod: setMethod, isIndexer: isIndexer)); }
public static IPropertySymbol OverrideProperty( this SyntaxGenerator codeFactory, IPropertySymbol overriddenProperty, SymbolModifiers modifiers, INamedTypeSymbol containingType, Document document, CancellationToken cancellationToken) { var getAccessibility = overriddenProperty.GetMethod.ComputeResultantAccessibility(containingType); var setAccessibility = overriddenProperty.SetMethod.ComputeResultantAccessibility(containingType); SyntaxNode getBody = null; SyntaxNode setBody = null; // Implement an abstract property by throwing not implemented in accessors. if (overriddenProperty.IsAbstract) { getBody = codeFactory.CreateThrowNotImplementStatement(document.Project.GetCompilationAsync(cancellationToken).WaitAndGetResult(cancellationToken)); setBody = getBody; } else if (overriddenProperty.IsIndexer() && document.Project.Language == LanguageNames.CSharp) { // Indexer: return or set base[]. Only in C#, since VB must refer to these by name. getBody = codeFactory.ReturnStatement( codeFactory.ElementAccessExpression( codeFactory.BaseExpression(), codeFactory.CreateArguments(overriddenProperty.Parameters))); setBody = codeFactory.ExpressionStatement( codeFactory.AssignmentStatement( codeFactory.ElementAccessExpression( codeFactory.BaseExpression(), codeFactory.CreateArguments(overriddenProperty.Parameters)), codeFactory.IdentifierName("value"))); } else if (overriddenProperty.GetParameters().Any()) { // Call accessors directly if C# overriding VB if (document.Project.Language == LanguageNames.CSharp && SymbolFinder.FindSourceDefinitionAsync(overriddenProperty, document.Project.Solution) .WaitAndGetResult(CancellationToken.None).Language == LanguageNames.VisualBasic) { var getName = overriddenProperty.GetMethod != null ? overriddenProperty.GetMethod.Name : null; var setName = overriddenProperty.SetMethod != null ? overriddenProperty.SetMethod.Name : null; getBody = getName == null ? null : codeFactory.ReturnStatement( codeFactory.InvocationExpression( codeFactory.MemberAccessExpression( codeFactory.BaseExpression(), codeFactory.IdentifierName(getName)), codeFactory.CreateArguments(overriddenProperty.Parameters))); setBody = setName == null ? null : codeFactory.ExpressionStatement( codeFactory.InvocationExpression( codeFactory.MemberAccessExpression( codeFactory.BaseExpression(), codeFactory.IdentifierName(setName)), codeFactory.CreateArguments(overriddenProperty.SetMethod.GetParameters()))); } else { getBody = codeFactory.ReturnStatement( codeFactory.InvocationExpression( codeFactory.MemberAccessExpression( codeFactory.BaseExpression(), codeFactory.IdentifierName(overriddenProperty.Name)), codeFactory.CreateArguments(overriddenProperty.Parameters))); setBody = codeFactory.ExpressionStatement( codeFactory.AssignmentStatement( codeFactory.InvocationExpression( codeFactory.MemberAccessExpression( codeFactory.BaseExpression(), codeFactory.IdentifierName(overriddenProperty.Name)), codeFactory.CreateArguments(overriddenProperty.Parameters)), codeFactory.IdentifierName("value"))); } } else { // Regular property: return or set the base property getBody = codeFactory.ReturnStatement( codeFactory.MemberAccessExpression( codeFactory.BaseExpression(), codeFactory.IdentifierName(overriddenProperty.Name))); setBody = codeFactory.ExpressionStatement( codeFactory.AssignmentStatement( codeFactory.MemberAccessExpression( codeFactory.BaseExpression(), codeFactory.IdentifierName(overriddenProperty.Name)), codeFactory.IdentifierName("value"))); } // Only generate a getter if the base getter is accessible. IMethodSymbol accessorGet = null; if (overriddenProperty.GetMethod != null && overriddenProperty.GetMethod.IsAccessibleWithin(containingType)) { accessorGet = CodeGenerationSymbolFactory.CreateMethodSymbol( overriddenProperty.GetMethod, accessibility: getAccessibility, statements: new[] { getBody }, modifiers: modifiers); } // Only generate a setter if the base setter is accessible. IMethodSymbol accessorSet = null; if (overriddenProperty.SetMethod != null && overriddenProperty.SetMethod.IsAccessibleWithin(containingType) && overriddenProperty.SetMethod.DeclaredAccessibility != Accessibility.Private) { accessorSet = CodeGenerationSymbolFactory.CreateMethodSymbol( overriddenProperty.SetMethod, accessibility: setAccessibility, statements: new[] { setBody }, modifiers: modifiers); } return CodeGenerationSymbolFactory.CreatePropertySymbol( overriddenProperty, accessibility: overriddenProperty.ComputeResultantAccessibility(containingType), modifiers: modifiers, name: overriddenProperty.Name, isIndexer: overriddenProperty.IsIndexer(), getMethod: accessorGet, setMethod: accessorSet); }
/// <summary> /// Creates a field symbol that can be used to describe a field declaration. /// </summary> public static IFieldSymbol CreateFieldSymbol(IList <AttributeData> attributes, Accessibility accessibility, SymbolModifiers modifiers, ITypeSymbol type, string name, bool hasConstantValue = false, object constantValue = null, SyntaxNode initializer = null) { var result = new CodeGenerationFieldSymbol(null, attributes, accessibility, modifiers, type, name, hasConstantValue, constantValue); CodeGenerationFieldInfo.Attach(result, modifiers.IsUnsafe, modifiers.IsWithEvents, initializer); return(result); }
/// <summary> /// Creates a field declaration. /// </summary> public abstract SyntaxNode FieldDeclaration( string name, SyntaxNode type, Accessibility accessibility = Accessibility.NotApplicable, SymbolModifiers modifiers = default(SymbolModifiers), SyntaxNode initializer = null);
/// <summary> /// Creates a constructor symbol that can be used to describe a constructor declaration. /// </summary> public static IMethodSymbol CreateConstructorSymbol(IList <AttributeData> attributes, Accessibility accessibility, SymbolModifiers modifiers, string typeName, IList <IParameterSymbol> parameters, IList <SyntaxNode> statements = null, IList <SyntaxNode> baseConstructorArguments = null, IList <SyntaxNode> thisConstructorArguments = null) { var result = new CodeGenerationConstructorSymbol(null, attributes, accessibility, modifiers, parameters); CodeGenerationConstructorInfo.Attach(result, typeName, statements, baseConstructorArguments, thisConstructorArguments); return(result); }
/// <summary> /// Creates a named type symbol that can be used to describe a named type declaration. /// </summary> public static INamedTypeSymbol CreateNamedTypeSymbol(IList<AttributeData> attributes, Accessibility accessibility, SymbolModifiers modifiers, TypeKind typeKind, string name, IList<ITypeParameterSymbol> typeParameters = null, INamedTypeSymbol baseType = null, IList<INamedTypeSymbol> interfaces = null, SpecialType specialType = SpecialType.None, IList<ISymbol> members = null) { members = members ?? SpecializedCollections.EmptyList<ISymbol>(); return new CodeGenerationNamedTypeSymbol( null, attributes, accessibility, modifiers, typeKind, name, typeParameters, baseType, interfaces, specialType, members.Where(m => !(m is INamedTypeSymbol)).ToList(), members.OfType<INamedTypeSymbol>().Select(n => n.ToCodeGenerationSymbol()).ToList(), enumUnderlyingType: null); }
internal static IMethodSymbol CreateMethodSymbol(INamedTypeSymbol containingType, IList <AttributeData> attributes, Accessibility accessibility, SymbolModifiers modifiers, ITypeSymbol returnType, IMethodSymbol explicitInterfaceSymbol, string name, IList <ITypeParameterSymbol> typeParameters, IList <IParameterSymbol> parameters, IList <SyntaxNode> statements = null, IList <SyntaxNode> handlesExpressions = null, IList <AttributeData> returnTypeAttributes = null) { var result = new CodeGenerationMethodSymbol(containingType, attributes, accessibility, modifiers, returnType, explicitInterfaceSymbol, name, typeParameters, parameters, returnTypeAttributes); CodeGenerationMethodInfo.Attach(result, modifiers.IsNew, modifiers.IsUnsafe, modifiers.IsPartial, modifiers.IsAsync, statements, handlesExpressions); return(result); }
/// <summary> /// Creates a struct declaration. /// </summary> public abstract SyntaxNode StructDeclaration( string name, IEnumerable<string> typeParameters = null, Accessibility accessibility = Accessibility.NotApplicable, SymbolModifiers modifiers = default(SymbolModifiers), IEnumerable<SyntaxNode> interfaceTypes = null, IEnumerable<SyntaxNode> members = null);
internal static IMethodSymbol CreateMethodSymbol(INamedTypeSymbol containingType, IList<AttributeData> attributes, Accessibility accessibility, SymbolModifiers modifiers, ITypeSymbol returnType, IMethodSymbol explicitInterfaceSymbol, string name, IList<ITypeParameterSymbol> typeParameters, IList<IParameterSymbol> parameters, IList<SyntaxNode> statements = null, IList<SyntaxNode> handlesExpressions = null, IList<AttributeData> returnTypeAttributes = null) { var result = new CodeGenerationMethodSymbol(containingType, attributes, accessibility, modifiers, returnType, explicitInterfaceSymbol, name, typeParameters, parameters, returnTypeAttributes); CodeGenerationMethodInfo.Attach(result, modifiers.IsNew, modifiers.IsUnsafe, modifiers.IsPartial, modifiers.IsAsync, statements, handlesExpressions); return result; }
/// <summary> /// Creates a method symbol that can be used to describe a method declaration. /// </summary> public static IMethodSymbol CreateMethodSymbol(IList<AttributeData> attributes, Accessibility accessibility, SymbolModifiers modifiers, ITypeSymbol returnType, IMethodSymbol explicitInterfaceSymbol, string name, IList<ITypeParameterSymbol> typeParameters, IList<IParameterSymbol> parameters, IList<SyntaxNode> statements = null, IList<SyntaxNode> handlesExpressions = null, IList<AttributeData> returnTypeAttributes = null) { return CreateMethodSymbol(null, attributes, accessibility, modifiers, returnType, explicitInterfaceSymbol, name, typeParameters, parameters, statements, handlesExpressions, returnTypeAttributes); }