public ClassNestedStructWithCodeAnalysis(
ClassMemberVisibilityModifier visibility,
string name)
: this()
{
Syntax = StructDeclarationSyntaxExtensions.ToSyntax(name, visibility);
}
public AbstractPropertyWithCodeAnalysis(
ClassMemberVisibilityModifier visibility,
ITypeReferenceWithCodeAnalysis type,
string name,
AccessorTypes accessors)
: this()
{
List <AccessorDeclarationSyntax> accessorSyntax = new List <AccessorDeclarationSyntax>();
if (accessors.HasFlag(AccessorTypes.Get))
{
accessorSyntax.Add(SyntaxFactory.AccessorDeclaration(SyntaxKind.GetKeyword));
}
if (accessors.HasFlag(AccessorTypes.Set))
{
accessorSyntax.Add(SyntaxFactory.AccessorDeclaration(SyntaxKind.SetKeyword));
}
Syntax = SyntaxFactory.PropertyDeclaration(
default(SyntaxList <AttributeListSyntax>),
default(SyntaxTokenList).WithClassMemberVisibilityModifier(visibility).Add(SyntaxKind.AbstractKeyword),
type.Syntax,
null,
SyntaxFactory.Identifier(name),
SyntaxFactory.AccessorList(SyntaxFactory.List(accessorSyntax)));
}
public ClassIndexerWithCodeAnalysis(
ClassMemberVisibilityModifier visibility,
ITypeReferenceWithCodeAnalysis type,
IEnumerable <IndexerParameterWithCodeAnalysis> parameters,
MethodBodyWithCodeAnalysis getAccessor,
MethodBodyWithCodeAnalysis setAccessor)
: this()
{
var parameterSyntax = parameters.Select(parameter => parameter.Syntax);
List <AccessorDeclarationSyntax> accessorSyntax = new List <AccessorDeclarationSyntax>();
if (getAccessor != null)
{
accessorSyntax.Add(SyntaxFactory.AccessorDeclaration(SyntaxKind.GetKeyword, getAccessor.Syntax));
}
if (setAccessor != null)
{
accessorSyntax.Add(SyntaxFactory.AccessorDeclaration(SyntaxKind.SetKeyword, setAccessor.Syntax));
}
Syntax = SyntaxFactory.IndexerDeclaration(
default(SyntaxList <AttributeListSyntax>),
default(SyntaxTokenList).WithClassMemberVisibilityModifier(visibility),
type.Syntax,
null,
SyntaxFactory.BracketedParameterList(SyntaxFactory.SeparatedList(parameterSyntax)),
SyntaxFactory.AccessorList(SyntaxFactory.List(accessorSyntax)));
}
public SealedPartialClassConstantWithCodeAnalysis(
ClassMemberVisibilityModifier visibility,
ITypeReferenceWithCodeAnalysis type,
params ConstantWithCodeAnalysis[] constants)
: this(new SealedClassConstantWithCodeAnalysis(visibility, type, constants))
{
}
public StaticClassPropertyWithCodeAnalysis(
ClassMemberVisibilityModifier visibility,
ITypeReferenceWithCodeAnalysis type,
string name,
MethodBodyWithCodeAnalysis getAccessor,
MethodBodyWithCodeAnalysis setAccessor)
: this()
{
List <AccessorDeclarationSyntax> accessorSyntax = new List <AccessorDeclarationSyntax>();
if (getAccessor != null)
{
accessorSyntax.Add(SyntaxFactory.AccessorDeclaration(SyntaxKind.GetKeyword, getAccessor.Syntax));
}
if (setAccessor != null)
{
accessorSyntax.Add(SyntaxFactory.AccessorDeclaration(SyntaxKind.SetKeyword, setAccessor.Syntax));
}
Syntax = SyntaxFactory.PropertyDeclaration(
default(SyntaxList <AttributeListSyntax>),
default(SyntaxTokenList).WithClassMemberVisibilityModifier(visibility),
type.Syntax,
null,
SyntaxFactory.Identifier(name),
SyntaxFactory.AccessorList(SyntaxFactory.List(accessorSyntax)));
}
public AbstractClassEventWithCodeAnalysis(
ClassMemberVisibilityModifier visibility,
DelegateReferenceWithCodeAnalysis type,
string name)
{
@event = new ClassEventWithCodeAnalysis(visibility, type, name);
}
public AbstractPartialClassFieldWithCodeAnalysis(
ClassMemberVisibilityModifier visibility,
ITypeReferenceWithCodeAnalysis type,
params string[] names)
: this(new AbstractClassFieldWithCodeAnalysis(visibility, type, names))
{
}
public SealedClassFieldWithCodeAnalysis(
ClassMemberVisibilityModifier visibility,
ITypeReferenceWithCodeAnalysis type,
params string[] names)
: this(new ClassFieldWithCodeAnalysis(visibility, type, names))
{
}
public PartialClassEventWithCodeAnalysis(
ClassMemberVisibilityModifier visibility,
DelegateReferenceWithCodeAnalysis type,
string name)
: this(new ClassEventWithCodeAnalysis(visibility, type, name))
{
}
public NestedStaticClassNestedPartialClassWithCodeAnalysis(
ClassMemberVisibilityModifier visibility,
string name)
: this()
{
Syntax = ClassDeclarationSyntaxExtensions.ToSyntax(name, visibility, SyntaxKind.PartialKeyword);
}
public static SyntaxTokenList WithAbstractMemberVisibilityModifier(
this SyntaxTokenList tokens,
AbstractMemberVisibilityModifier modifier)
{
ClassMemberVisibilityModifier memberModifier = ClassMemberVisibilityModifier.None;
switch (modifier)
{
case AbstractMemberVisibilityModifier.Public:
memberModifier = ClassMemberVisibilityModifier.Public;
break;
case AbstractMemberVisibilityModifier.Internal:
memberModifier = ClassMemberVisibilityModifier.Internal;
break;
case AbstractMemberVisibilityModifier.ProtectedInternal:
memberModifier = ClassMemberVisibilityModifier.ProtectedInternal;
break;
case AbstractMemberVisibilityModifier.Protected:
memberModifier = ClassMemberVisibilityModifier.Protected;
break;
}
return(tokens.WithClassMemberVisibilityModifier(memberModifier));
}
public static SyntaxTokenList WithClassAccessorVisibilityModifier(
this SyntaxTokenList tokens,
ClassAccessorVisibilityModifier modifier)
{
ClassMemberVisibilityModifier memberModifier = ClassMemberVisibilityModifier.None;
switch (modifier)
{
case ClassAccessorVisibilityModifier.Internal:
memberModifier = ClassMemberVisibilityModifier.Internal;
break;
case ClassAccessorVisibilityModifier.ProtectedInternal:
memberModifier = ClassMemberVisibilityModifier.ProtectedInternal;
break;
case ClassAccessorVisibilityModifier.Protected:
memberModifier = ClassMemberVisibilityModifier.Protected;
break;
case ClassAccessorVisibilityModifier.Private:
memberModifier = ClassMemberVisibilityModifier.Private;
break;
}
return(tokens.WithClassMemberVisibilityModifier(memberModifier));
}
internal ClassAccessorWithMonoCecil(IHasClassMemberVisibilityModifier parentVisibility, AccessorWithMonoCecil accessor)
{
this.accessor = accessor;
ClassMemberVisibilityModifier classVisibility = accessor.MethodDefinition.ClassVisibility();
if (parentVisibility.Visibility == classVisibility)
{
visibility = ClassAccessorVisibilityModifier.None;
}
else
{
switch (classVisibility)
{
case ClassMemberVisibilityModifier.Internal:
visibility = ClassAccessorVisibilityModifier.Internal;
break;
case ClassMemberVisibilityModifier.ProtectedInternal:
visibility = ClassAccessorVisibilityModifier.ProtectedInternal;
break;
case ClassMemberVisibilityModifier.Protected:
visibility = ClassAccessorVisibilityModifier.Protected;
break;
case ClassMemberVisibilityModifier.Private:
visibility = ClassAccessorVisibilityModifier.Private;
break;
}
}
}
public static SyntaxTokenList WithClassMemberVisibilityModifier(
this SyntaxTokenList tokens,
ClassMemberVisibilityModifier modifier)
{
tokens = tokens.Remove(visibilityModifierTokens);
switch (modifier)
{
case ClassMemberVisibilityModifier.Public:
return(tokens.Insert(0, SyntaxKind.PublicKeyword));
case ClassMemberVisibilityModifier.Internal:
return(tokens.Insert(0, SyntaxKind.InternalKeyword));
case ClassMemberVisibilityModifier.ProtectedInternal:
return(tokens.InsertRange(0, SyntaxKind.ProtectedKeyword, SyntaxKind.InternalKeyword));
case ClassMemberVisibilityModifier.Protected:
return(tokens.Insert(0, SyntaxKind.ProtectedKeyword));
case ClassMemberVisibilityModifier.Private:
return(tokens.Insert(0, SyntaxKind.PrivateKeyword));
}
return(tokens);
}
public AbstractIndexerWithCodeAnalysis(
ClassMemberVisibilityModifier visibility,
ITypeReferenceWithCodeAnalysis type,
IEnumerable <IndexerParameterWithCodeAnalysis> parameters,
AccessorTypes accessors)
: this()
{
var parameterSyntax = parameters.Select(parameter => parameter.Syntax);
List <AccessorDeclarationSyntax> accessorSyntax = new List <AccessorDeclarationSyntax>();
if (accessors.HasFlag(AccessorTypes.Get))
{
accessorSyntax.Add(SyntaxFactory.AccessorDeclaration(SyntaxKind.GetKeyword));
}
if (accessors.HasFlag(AccessorTypes.Set))
{
accessorSyntax.Add(SyntaxFactory.AccessorDeclaration(SyntaxKind.SetKeyword));
}
Syntax = SyntaxFactory.IndexerDeclaration(
default(SyntaxList <AttributeListSyntax>),
default(SyntaxTokenList).WithClassMemberVisibilityModifier(visibility).Add(SyntaxKind.AbstractKeyword),
type.Syntax,
null,
SyntaxFactory.BracketedParameterList(SyntaxFactory.SeparatedList(parameterSyntax)),
SyntaxFactory.AccessorList(SyntaxFactory.List(accessorSyntax)));
}
public AbstractClassConstantWithCodeAnalysis(
ClassMemberVisibilityModifier visibility,
ITypeReferenceWithCodeAnalysis type,
params ConstantWithCodeAnalysis[] constants)
: this(new ClassConstantWithCodeAnalysis(visibility, type, constants))
{
}
public AbstractPartialClassAbstractPropertyWithCodeAnalysis(
ClassMemberVisibilityModifier visibility,
ITypeReferenceWithCodeAnalysis type,
string name,
AccessorTypes accessors)
: this(new AbstractPropertyWithCodeAnalysis(visibility, type, name, accessors))
{
}
public PartialClassConstructorWithCodeAnalysis(
ClassMemberVisibilityModifier visibility,
string name,
IEnumerable <ConstructorParameterWithCodeAnalysis> parameters,
MethodBodyWithCodeAnalysis body)
: this(new ClassConstructorWithCodeAnalysis(visibility, name, parameters, body))
{
}
public AbstractPartialClassAbstractIndexerWithCodeAnalysis(
ClassMemberVisibilityModifier visibility,
ITypeReferenceWithCodeAnalysis type,
IEnumerable <IndexerParameterWithCodeAnalysis> parameters,
AccessorTypes accessors)
: this(new AbstractIndexerWithCodeAnalysis(visibility, type, parameters, accessors))
{
}
public AbstractPartialClassAbstractMethodWithCodeAnalysis(
ClassMemberVisibilityModifier visibility,
ITypeReferenceWithCodeAnalysis returnType,
string name,
IEnumerable <MethodParameterWithCodeAnalysis> parameters)
: this(new AbstractMethodWithCodeAnalysis(visibility, returnType, name, parameters))
{
}
public AbstractClassConstantWithCodeAnalysis(
ClassMemberVisibilityModifier visibility,
ITypeReferenceWithCodeAnalysis type,
string name,
IExpressionWithCodeAnalysis value)
: this(new ClassConstantWithCodeAnalysis(visibility, type, name, value))
{
}
public SealedPartialClassNestedDelegateWithCodeAnalysis(
ClassMemberVisibilityModifier visibility,
ITypeReferenceWithCodeAnalysis returnType,
string name,
IEnumerable <DelegateParameterWithCodeAnalysis> parameters)
: this(new SealedClassNestedDelegateWithCodeAnalysis(visibility, returnType, name, parameters))
{
}
public SealedPartialClassMethodWithCodeAnalysis(
ClassMemberVisibilityModifier visibility,
ITypeReferenceWithCodeAnalysis returnType,
string name,
IEnumerable <MethodParameterWithCodeAnalysis> parameters,
MethodBodyWithCodeAnalysis body)
: this(new SealedClassMethodWithCodeAnalysis(visibility, returnType, name, parameters, body))
{
}
public SealedClassEventPropertyWithCodeAnalysis(
ClassMemberVisibilityModifier visibility,
DelegateReferenceWithCodeAnalysis type,
string name,
MethodBodyWithCodeAnalysis addAccessor,
MethodBodyWithCodeAnalysis removeAccessor)
: this(new ClassEventPropertyWithCodeAnalysis(visibility, type, name, addAccessor, removeAccessor))
{
}
public SealedPartialClassIndexerWithCodeAnalysis(
ClassMemberVisibilityModifier visibility,
ITypeReferenceWithCodeAnalysis type,
IEnumerable <IndexerParameterWithCodeAnalysis> parameters,
MethodBodyWithCodeAnalysis getAccessor,
MethodBodyWithCodeAnalysis setAccessor)
: this(new SealedClassIndexerWithCodeAnalysis(visibility, type, parameters, getAccessor, setAccessor))
{
}
public AbstractClassConversionOperatorWithCodeAnalysis(
ClassMemberVisibilityModifier visibility,
ConversionOperatorType operatorType,
ITypeReferenceWithCodeAnalysis returnType,
OperatorParameterWithCodeAnalysis parameter,
MethodBodyWithCodeAnalysis body)
: this(new ClassConversionOperatorWithCodeAnalysis(visibility, operatorType, returnType, parameter, body))
{
}
public static ClassDeclarationSyntax ToSyntax(
string name,
ClassMemberVisibilityModifier visibility,
params SyntaxKind[] modifiers)
{
return(ToSyntax(
name,
default(SyntaxTokenList).WithClassMemberVisibilityModifier(visibility).AddRange(modifiers)));
}
public SealedPartialClassPropertyWithCodeAnalysis(
ClassMemberVisibilityModifier visibility,
ITypeReferenceWithCodeAnalysis type,
string name,
MethodBodyWithCodeAnalysis getAccessor,
MethodBodyWithCodeAnalysis setAccessor)
: this(new SealedClassPropertyWithCodeAnalysis(visibility, type, name, getAccessor, setAccessor))
{
}
public SealedPartialClassOperatorOverloadWithCodeAnalysis(
ClassMemberVisibilityModifier visibility,
ITypeReferenceWithCodeAnalysis returnType,
OperatorOverloadType operatorType,
IEnumerable <OperatorParameterWithCodeAnalysis> parameters,
MethodBodyWithCodeAnalysis body)
: this(new SealedClassOperatorOverloadWithCodeAnalysis(visibility, returnType, operatorType, parameters, body))
{
}
public AbstractClassIndexerWithCodeAnalysis(
ClassMemberVisibilityModifier visibility,
ITypeReferenceWithCodeAnalysis type,
IEnumerable <IndexerParameterWithCodeAnalysis> parameters,
MethodBodyWithCodeAnalysis getAccessor,
MethodBodyWithCodeAnalysis setAccessor)
{
indexer = new ClassIndexerWithCodeAnalysis(visibility, type, parameters, getAccessor, setAccessor);
}
