Пример #1
0
 public StaticPartialClassEventWithCodeAnalysis(
     StaticClassMemberVisibilityModifier visibility,
     DelegateReferenceWithCodeAnalysis type,
     string name)
     : this(new StaticClassEventWithCodeAnalysis(visibility, type, name))
 {
 }
        public NestedStaticClassPropertyWithCodeAnalysis(
            StaticClassMemberVisibilityModifier 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).WithStaticClassMemberVisibilityModifier(visibility),
                type.Syntax,
                null,
                SyntaxFactory.Identifier(name),
                SyntaxFactory.AccessorList(SyntaxFactory.List(accessorSyntax)));
        }
 public StaticPartialClassFieldWithCodeAnalysis(
     StaticClassMemberVisibilityModifier visibility,
     ITypeReferenceWithCodeAnalysis type,
     params string[] names)
     : this(new StaticClassFieldWithCodeAnalysis(visibility, type, names))
 {
 }
Пример #4
0
 public static SyntaxTokenList WithStaticClassMemberVisibilityModifier(
     this SyntaxTokenList tokens,
     StaticClassMemberVisibilityModifier modifier)
 {
     return(tokens.WithClassMemberVisibilityModifier(
                staticClassVisibilityModifierMap.First(entry => entry.Value == modifier).Key));
 }
 public StaticPartialClassConstantWithCodeAnalysis(
     StaticClassMemberVisibilityModifier visibility,
     ITypeReferenceWithCodeAnalysis type,
     params ConstantWithCodeAnalysis[] constants)
     : this(new StaticClassConstantWithCodeAnalysis(visibility, type, constants))
 {
 }
Пример #6
0
 public StaticClassConstantWithCodeAnalysis(
     StaticClassMemberVisibilityModifier visibility,
     ITypeReferenceWithCodeAnalysis type,
     string name,
     IExpressionWithCodeAnalysis value)
     : this(visibility, type, new ConstantWithCodeAnalysis(name, value))
 {
 }
 public StaticPartialClassMethodWithCodeAnalysis(
     StaticClassMemberVisibilityModifier visibility,
     ITypeReferenceWithCodeAnalysis returnType,
     string name,
     IEnumerable <MethodParameterWithCodeAnalysis> parameters,
     MethodBodyWithCodeAnalysis body)
     : this(new StaticClassMethodWithCodeAnalysis(visibility, returnType, name, parameters, body))
 {
 }
Пример #8
0
 public StaticPartialClassEventPropertyWithCodeAnalysis(
     StaticClassMemberVisibilityModifier visibility,
     DelegateReferenceWithCodeAnalysis type,
     string name,
     MethodBodyWithCodeAnalysis addAccessor,
     MethodBodyWithCodeAnalysis removeAccessor)
     : this(new StaticClassEventPropertyWithCodeAnalysis(visibility, type, name, addAccessor, removeAccessor))
 {
 }
Пример #9
0
 public NestedStaticPartialClassPropertyWithCodeAnalysis(
     StaticClassMemberVisibilityModifier visibility,
     ITypeReferenceWithCodeAnalysis type,
     string name,
     MethodBodyWithCodeAnalysis getAccessor,
     MethodBodyWithCodeAnalysis setAccessor)
     : this(new NestedStaticClassPropertyWithCodeAnalysis(visibility, type, name, getAccessor, setAccessor))
 {
 }
 public NestedStaticClassFieldWithCodeAnalysis(
     StaticClassMemberVisibilityModifier visibility,
     ITypeReferenceWithCodeAnalysis type,
     params string[] names)
     : this()
 {
     Syntax = SyntaxFactory.FieldDeclaration(
         default(SyntaxList <AttributeListSyntax>),
         default(SyntaxTokenList).WithStaticClassMemberVisibilityModifier(visibility),
         SyntaxFactory.VariableDeclaration(type.Syntax, SyntaxFactory.SeparatedList(names.Select(SyntaxFactory.VariableDeclarator))));
 }
Пример #11
0
        internal static void AddStaticClassMemberVisibilityModifierSteps(
            this List <ISourceCodeBuilderStep> steps,
            StaticClassMemberVisibilityModifier visibility)
        {
            if (visibility == StaticClassMemberVisibilityModifier.None)
            {
                return;
            }

            steps.Add(new WriteStaticClassMemberVisibilityModifier(visibility));
            steps.Add(new WriteWhitespace());
        }
Пример #12
0
        public StaticClassConstantWithCodeAnalysis(
            StaticClassMemberVisibilityModifier visibility,
            ITypeReferenceWithCodeAnalysis type,
            params ConstantWithCodeAnalysis[] constants)
            : this()
        {
            IEnumerable <VariableDeclaratorSyntax> syntax = constants.Select(constant => constant.Syntax);

            Syntax = SyntaxFactory.FieldDeclaration(
                default(SyntaxList <AttributeListSyntax>),
                default(SyntaxTokenList).WithStaticClassMemberVisibilityModifier(visibility),
                SyntaxFactory.VariableDeclaration(type.Syntax, SyntaxFactory.SeparatedList(syntax)));
        }
        public StaticClassEventWithCodeAnalysis(
            StaticClassMemberVisibilityModifier visibility,
            DelegateReferenceWithCodeAnalysis type,
            string name)
            : this()
        {
            VariableDeclaratorSyntax syntax = SyntaxFactory.VariableDeclarator(name);

            Syntax = SyntaxFactory.EventFieldDeclaration(
                default(SyntaxList <AttributeListSyntax>),
                default(SyntaxTokenList).WithStaticClassMemberVisibilityModifier(visibility),
                SyntaxFactory.VariableDeclaration(type.Syntax, SyntaxFactory.SingletonSeparatedList(syntax)));
        }
 public StaticClassMethodWithCodeAnalysis(
     StaticClassMemberVisibilityModifier visibility,
     ITypeReferenceWithCodeAnalysis returnType,
     string name,
     IEnumerable <MethodParameterWithCodeAnalysis> parameters,
     MethodBodyWithCodeAnalysis body)
     : this()
 {
     Syntax = SyntaxFactory.MethodDeclaration(
         default(SyntaxList <AttributeListSyntax>),
         default(SyntaxTokenList).WithStaticClassMemberVisibilityModifier(visibility),
         returnType.Syntax,
         null,
         SyntaxFactory.Identifier(name),
         null,
         SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList(parameters.Select(parameter => parameter.Syntax))),
         default(SyntaxList <TypeParameterConstraintClauseSyntax>),
         body.Syntax,
         null);
 }
        public StaticClassEventPropertyWithCodeAnalysis(
            StaticClassMemberVisibilityModifier visibility,
            DelegateReferenceWithCodeAnalysis type,
            string name,
            MethodBodyWithCodeAnalysis addAccessor,
            MethodBodyWithCodeAnalysis removeAccessor)
            : this()
        {
            IEnumerable <AccessorDeclarationSyntax> accessors = new AccessorDeclarationSyntax[]
            {
                SyntaxFactory.AccessorDeclaration(SyntaxKind.AddKeyword, addAccessor.Syntax),
                SyntaxFactory.AccessorDeclaration(SyntaxKind.RemoveKeyword, removeAccessor.Syntax)
            };

            Syntax = SyntaxFactory.EventDeclaration(
                default(SyntaxList <AttributeListSyntax>),
                default(SyntaxTokenList).WithStaticClassMemberVisibilityModifier(visibility),
                type.Syntax,
                null,
                SyntaxFactory.Identifier(name),
                SyntaxFactory.AccessorList(SyntaxFactory.List(accessors)));
        }
        internal StaticClassAccessorWithMonoCecil(IHasStaticClassMemberVisibilityModifier parentVisibility, AccessorWithMonoCecil accessor)
        {
            this.accessor = accessor;
            StaticClassMemberVisibilityModifier staticClassVisibility = accessor.MethodDefinition.StaticClassVisibility();

            if (parentVisibility.Visibility == staticClassVisibility)
            {
                visibility = StaticClassAccessorVisibilityModifier.None;
            }
            else
            {
                switch (staticClassVisibility)
                {
                case StaticClassMemberVisibilityModifier.Internal:
                    visibility = StaticClassAccessorVisibilityModifier.Internal;
                    break;

                case StaticClassMemberVisibilityModifier.Private:
                    visibility = StaticClassAccessorVisibilityModifier.Private;
                    break;
                }
            }
        }
 public WriteStaticClassMemberVisibilityModifier(StaticClassMemberVisibilityModifier modifier)
 {
     Modifier = modifier;
 }