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