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