C# (CSharp) StyleCop.Analyzers.Lightup LightupHelpers示例

示例#1

 static IRangeOperationWrapper()
 {
     WrappedType          = OperationWrapperHelper.GetWrappedType(typeof(IRangeOperationWrapper));
     LeftOperandAccessor  = LightupHelpers.CreateOperationPropertyAccessor <IOperation, IOperation>(WrappedType, nameof(LeftOperand));
     RightOperandAccessor = LightupHelpers.CreateOperationPropertyAccessor <IOperation, IOperation>(WrappedType, nameof(RightOperand));
     IsLiftedAccessor     = LightupHelpers.CreateOperationPropertyAccessor <IOperation, bool>(WrappedType, nameof(IsLifted));
     MethodAccessor       = LightupHelpers.CreateOperationPropertyAccessor <IOperation, IMethodSymbol>(WrappedType, nameof(Method));
 }

示例#2

 static ITryOperationWrapper()
 {
     WrappedType       = OperationWrapperHelper.GetWrappedType(typeof(ITryOperationWrapper));
     BodyAccessor      = LightupHelpers.CreateOperationPropertyAccessor <IOperation, IOperation>(WrappedType, nameof(Body));
     CatchesAccessor   = LightupHelpers.CreateOperationListPropertyAccessor <IOperation>(WrappedType, nameof(Catches));
     FinallyAccessor   = LightupHelpers.CreateOperationPropertyAccessor <IOperation, IOperation>(WrappedType, nameof(Finally));
     ExitLabelAccessor = LightupHelpers.CreateOperationPropertyAccessor <IOperation, ILabelSymbol>(WrappedType, nameof(ExitLabel));
 }

示例#3

 static IInvocationOperationWrapper()
 {
     WrappedType          = OperationWrapperHelper.GetWrappedType(typeof(IInvocationOperationWrapper));
     TargetMethodAccessor = LightupHelpers.CreateOperationPropertyAccessor <IOperation, IMethodSymbol>(WrappedType, nameof(TargetMethod));
     InstanceAccessor     = LightupHelpers.CreateOperationPropertyAccessor <IOperation, IOperation>(WrappedType, nameof(Instance));
     IsVirtualAccessor    = LightupHelpers.CreateOperationPropertyAccessor <IOperation, bool>(WrappedType, nameof(IsVirtual));
     ArgumentsAccessor    = LightupHelpers.CreateOperationListPropertyAccessor <IOperation>(WrappedType, nameof(Arguments));
 }

示例#4

文件： IForEachLoopOperationWrapper.g.cs 项目： zhuthree/StyleCopAnalyzers

 static IForEachLoopOperationWrapper()
 {
     WrappedType = OperationWrapperHelper.GetWrappedType(typeof(IForEachLoopOperationWrapper));
     LoopControlVariableAccessor = LightupHelpers.CreateOperationPropertyAccessor <IOperation, IOperation>(WrappedType, nameof(LoopControlVariable));
     CollectionAccessor          = LightupHelpers.CreateOperationPropertyAccessor <IOperation, IOperation>(WrappedType, nameof(Collection));
     NextVariablesAccessor       = LightupHelpers.CreateOperationPropertyAccessor <IOperation, ImmutableArray <IOperation> >(WrappedType, nameof(NextVariables));
     IsAsynchronousAccessor      = LightupHelpers.CreateOperationPropertyAccessor <IOperation, bool>(WrappedType, nameof(IsAsynchronous));
 }

示例#5

 static DeclarationPatternSyntaxWrapper()
 {
     DeclarationPatternSyntaxType = typeof(CSharpSyntaxNode).GetTypeInfo().Assembly.GetType(DeclarationPatternSyntaxTypeName);
     TypeAccessor            = LightupHelpers.CreateSyntaxPropertyAccessor <CSharpSyntaxNode, TypeSyntax>(DeclarationPatternSyntaxType, nameof(Type));
     DesignationAccessor     = LightupHelpers.CreateSyntaxPropertyAccessor <CSharpSyntaxNode, CSharpSyntaxNode>(DeclarationPatternSyntaxType, nameof(Designation));
     WithTypeAccessor        = LightupHelpers.CreateSyntaxWithPropertyAccessor <CSharpSyntaxNode, TypeSyntax>(DeclarationPatternSyntaxType, nameof(Type));
     WithDesignationAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor <CSharpSyntaxNode, CSharpSyntaxNode>(DeclarationPatternSyntaxType, nameof(Designation));
 }

示例#6

文件： TupleElementSyntaxWrapper.cs 项目： TechSmith/StyleCopAnalyzers

 static TupleElementSyntaxWrapper()
 {
     WrappedType            = WrapperHelper.GetWrappedType(typeof(TupleElementSyntaxWrapper));
     IdentifierAccessor     = LightupHelpers.CreateSyntaxPropertyAccessor <CSharpSyntaxNode, SyntaxToken>(WrappedType, nameof(Identifier));
     TypeAccessor           = LightupHelpers.CreateSyntaxPropertyAccessor <CSharpSyntaxNode, TypeSyntax>(WrappedType, nameof(Type));
     WithIdentifierAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor <CSharpSyntaxNode, SyntaxToken>(WrappedType, nameof(Identifier));
     WithTypeAccessor       = LightupHelpers.CreateSyntaxWithPropertyAccessor <CSharpSyntaxNode, TypeSyntax>(WrappedType, nameof(Type));
 }

示例#7

文件： ISwitchExpressionArmOperationWrapper.g.cs 项目： zhuthree/StyleCopAnalyzers

 static ISwitchExpressionArmOperationWrapper()
 {
     WrappedType     = OperationWrapperHelper.GetWrappedType(typeof(ISwitchExpressionArmOperationWrapper));
     PatternAccessor = LightupHelpers.CreateOperationPropertyAccessor <IOperation, IOperation>(WrappedType, nameof(Pattern));
     GuardAccessor   = LightupHelpers.CreateOperationPropertyAccessor <IOperation, IOperation>(WrappedType, nameof(Guard));
     ValueAccessor   = LightupHelpers.CreateOperationPropertyAccessor <IOperation, IOperation>(WrappedType, nameof(Value));
     LocalsAccessor  = LightupHelpers.CreateOperationPropertyAccessor <IOperation, ImmutableArray <ILocalSymbol> >(WrappedType, nameof(Locals));
 }

示例#8

文件： FunctionPointerCallingConventionSyntaxWrapper.g.cs 项目： wdolek/StyleCopAnalyzers

 static FunctionPointerCallingConventionSyntaxWrapper()
 {
     WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(FunctionPointerCallingConventionSyntaxWrapper));
     ManagedOrUnmanagedKeywordAccessor          = LightupHelpers.CreateSyntaxPropertyAccessor <CSharpSyntaxNode, SyntaxToken>(WrappedType, nameof(ManagedOrUnmanagedKeyword));
     UnmanagedCallingConventionListAccessor     = LightupHelpers.CreateSyntaxPropertyAccessor <CSharpSyntaxNode, CSharpSyntaxNode>(WrappedType, nameof(UnmanagedCallingConventionList));
     WithManagedOrUnmanagedKeywordAccessor      = LightupHelpers.CreateSyntaxWithPropertyAccessor <CSharpSyntaxNode, SyntaxToken>(WrappedType, nameof(ManagedOrUnmanagedKeyword));
     WithUnmanagedCallingConventionListAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor <CSharpSyntaxNode, CSharpSyntaxNode>(WrappedType, nameof(UnmanagedCallingConventionList));
 }

示例#9

文件： RelationalPatternSyntaxWrapper.g.cs 项目： wdolek/StyleCopAnalyzers

 static RelationalPatternSyntaxWrapper()
 {
     WrappedType               = SyntaxWrapperHelper.GetWrappedType(typeof(RelationalPatternSyntaxWrapper));
     OperatorTokenAccessor     = LightupHelpers.CreateSyntaxPropertyAccessor <CSharpSyntaxNode, SyntaxToken>(WrappedType, nameof(OperatorToken));
     ExpressionAccessor        = LightupHelpers.CreateSyntaxPropertyAccessor <CSharpSyntaxNode, ExpressionSyntax>(WrappedType, nameof(Expression));
     WithOperatorTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor <CSharpSyntaxNode, SyntaxToken>(WrappedType, nameof(OperatorToken));
     WithExpressionAccessor    = LightupHelpers.CreateSyntaxWithPropertyAccessor <CSharpSyntaxNode, ExpressionSyntax>(WrappedType, nameof(Expression));
 }

示例#10

文件： DeclarationExpressionSyntaxWrapper.g.cs 项目： wdolek/StyleCopAnalyzers

 static DeclarationExpressionSyntaxWrapper()
 {
     WrappedType             = SyntaxWrapperHelper.GetWrappedType(typeof(DeclarationExpressionSyntaxWrapper));
     TypeAccessor            = LightupHelpers.CreateSyntaxPropertyAccessor <ExpressionSyntax, TypeSyntax>(WrappedType, nameof(Type));
     DesignationAccessor     = LightupHelpers.CreateSyntaxPropertyAccessor <ExpressionSyntax, CSharpSyntaxNode>(WrappedType, nameof(Designation));
     WithTypeAccessor        = LightupHelpers.CreateSyntaxWithPropertyAccessor <ExpressionSyntax, TypeSyntax>(WrappedType, nameof(Type));
     WithDesignationAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor <ExpressionSyntax, CSharpSyntaxNode>(WrappedType, nameof(Designation));
 }

示例#11

 static IDynamicMemberReferenceOperationWrapper()
 {
     WrappedType            = OperationWrapperHelper.GetWrappedType(typeof(IDynamicMemberReferenceOperationWrapper));
     InstanceAccessor       = LightupHelpers.CreateOperationPropertyAccessor <IOperation, IOperation>(WrappedType, nameof(Instance));
     MemberNameAccessor     = LightupHelpers.CreateOperationPropertyAccessor <IOperation, string>(WrappedType, nameof(MemberName));
     TypeArgumentsAccessor  = LightupHelpers.CreateOperationPropertyAccessor <IOperation, ImmutableArray <ITypeSymbol> >(WrappedType, nameof(TypeArguments));
     ContainingTypeAccessor = LightupHelpers.CreateOperationPropertyAccessor <IOperation, ITypeSymbol>(WrappedType, nameof(ContainingType));
 }

示例#12

文件： ISwitchOperationWrapper.g.cs 项目： zhuthree/StyleCopAnalyzers

 static ISwitchOperationWrapper()
 {
     WrappedType       = OperationWrapperHelper.GetWrappedType(typeof(ISwitchOperationWrapper));
     LocalsAccessor    = LightupHelpers.CreateOperationPropertyAccessor <IOperation, ImmutableArray <ILocalSymbol> >(WrappedType, nameof(Locals));
     ValueAccessor     = LightupHelpers.CreateOperationPropertyAccessor <IOperation, IOperation>(WrappedType, nameof(Value));
     CasesAccessor     = LightupHelpers.CreateOperationListPropertyAccessor <IOperation>(WrappedType, nameof(Cases));
     ExitLabelAccessor = LightupHelpers.CreateOperationPropertyAccessor <IOperation, ILabelSymbol>(WrappedType, nameof(ExitLabel));
 }

示例#13

 static IUnaryOperationWrapper()
 {
     WrappedType            = OperationWrapperHelper.GetWrappedType(typeof(IUnaryOperationWrapper));
     OperandAccessor        = LightupHelpers.CreateOperationPropertyAccessor <IOperation, IOperation>(WrappedType, nameof(Operand));
     IsLiftedAccessor       = LightupHelpers.CreateOperationPropertyAccessor <IOperation, bool>(WrappedType, nameof(IsLifted));
     IsCheckedAccessor      = LightupHelpers.CreateOperationPropertyAccessor <IOperation, bool>(WrappedType, nameof(IsChecked));
     OperatorMethodAccessor = LightupHelpers.CreateOperationPropertyAccessor <IOperation, IMethodSymbol>(WrappedType, nameof(OperatorMethod));
 }

示例#14

文件： ThrowExpressionSyntaxWrapper.g.cs 项目： wdolek/StyleCopAnalyzers

 static ThrowExpressionSyntaxWrapper()
 {
     WrappedType              = SyntaxWrapperHelper.GetWrappedType(typeof(ThrowExpressionSyntaxWrapper));
     ThrowKeywordAccessor     = LightupHelpers.CreateSyntaxPropertyAccessor <ExpressionSyntax, SyntaxToken>(WrappedType, nameof(ThrowKeyword));
     ExpressionAccessor       = LightupHelpers.CreateSyntaxPropertyAccessor <ExpressionSyntax, ExpressionSyntax>(WrappedType, nameof(Expression));
     WithThrowKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor <ExpressionSyntax, SyntaxToken>(WrappedType, nameof(ThrowKeyword));
     WithExpressionAccessor   = LightupHelpers.CreateSyntaxWithPropertyAccessor <ExpressionSyntax, ExpressionSyntax>(WrappedType, nameof(Expression));
 }

示例#15

文件： LineOrSpanDirectiveTriviaSyntaxWrapper.g.cs 项目： roadz99/StyleCopAnalyzers

 static LineOrSpanDirectiveTriviaSyntaxWrapper()
 {
     WrappedType             = SyntaxWrapperHelper.GetWrappedType(typeof(LineOrSpanDirectiveTriviaSyntaxWrapper));
     LineKeywordAccessor     = LightupHelpers.CreateSyntaxPropertyAccessor <DirectiveTriviaSyntax, SyntaxToken>(WrappedType, nameof(LineKeyword));
     FileAccessor            = LightupHelpers.CreateSyntaxPropertyAccessor <DirectiveTriviaSyntax, SyntaxToken>(WrappedType, nameof(File));
     WithLineKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor <DirectiveTriviaSyntax, SyntaxToken>(WrappedType, nameof(LineKeyword));
     WithFileAccessor        = LightupHelpers.CreateSyntaxWithPropertyAccessor <DirectiveTriviaSyntax, SyntaxToken>(WrappedType, nameof(File));
 }

示例#16

 static WhenClauseSyntaxWrapper()
 {
     WrappedType             = WrapperHelper.GetWrappedType(typeof(WhenClauseSyntaxWrapper));
     WhenKeywordAccessor     = LightupHelpers.CreateSyntaxPropertyAccessor <CSharpSyntaxNode, SyntaxToken>(WrappedType, nameof(WhenKeyword));
     ConditionAccessor       = LightupHelpers.CreateSyntaxPropertyAccessor <CSharpSyntaxNode, ExpressionSyntax>(WrappedType, nameof(Condition));
     WithWhenKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor <CSharpSyntaxNode, SyntaxToken>(WrappedType, nameof(WhenKeyword));
     WithConditionAccessor   = LightupHelpers.CreateSyntaxWithPropertyAccessor <CSharpSyntaxNode, ExpressionSyntax>(WrappedType, nameof(Condition));
 }

示例#17

文件： AnalyzerConfigOptionsProviderWrapper.cs 项目： roadz99/StyleCopAnalyzers

        static AnalyzerConfigOptionsProviderWrapper()
        {
            WrappedType = WrapperHelper.GetWrappedType(typeof(AnalyzerConfigOptionsProviderWrapper));

            GlobalOptionsAccessor            = LightupHelpers.CreateSyntaxPropertyAccessor <object, object>(WrappedType, nameof(GlobalOptions));
            GetOptionsSyntaxTreeAccessor     = LightupHelpers.CreateSyntaxPropertyAccessor <object, SyntaxTree, object>(WrappedType, typeof(SyntaxTree), nameof(GetOptions));
            GetOptionsAdditionalTextAccessor = LightupHelpers.CreateSyntaxPropertyAccessor <object, AdditionalText, object>(WrappedType, typeof(AdditionalText), nameof(GetOptions));
        }

示例#18

文件： UnaryPatternSyntaxWrapper.g.cs 项目： wdolek/StyleCopAnalyzers

 static UnaryPatternSyntaxWrapper()
 {
     WrappedType               = SyntaxWrapperHelper.GetWrappedType(typeof(UnaryPatternSyntaxWrapper));
     OperatorTokenAccessor     = LightupHelpers.CreateSyntaxPropertyAccessor <CSharpSyntaxNode, SyntaxToken>(WrappedType, nameof(OperatorToken));
     PatternAccessor           = LightupHelpers.CreateSyntaxPropertyAccessor <CSharpSyntaxNode, CSharpSyntaxNode>(WrappedType, nameof(Pattern));
     WithOperatorTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor <CSharpSyntaxNode, SyntaxToken>(WrappedType, nameof(OperatorToken));
     WithPatternAccessor       = LightupHelpers.CreateSyntaxWithPropertyAccessor <CSharpSyntaxNode, CSharpSyntaxNode>(WrappedType, nameof(Pattern));
 }

示例#19

文件： RefExpressionSyntaxWrapper.cs 项目： scott-xu/StyleCopAnalyzers

 static RefExpressionSyntaxWrapper()
 {
     RefExpressionSyntaxType = typeof(CSharpSyntaxNode).GetTypeInfo().Assembly.GetType(RefExpressionSyntaxTypeName);
     RefKeywordAccessor      = LightupHelpers.CreateSyntaxPropertyAccessor <ExpressionSyntax, SyntaxToken>(RefExpressionSyntaxType, nameof(RefKeyword));
     ExpressionAccessor      = LightupHelpers.CreateSyntaxPropertyAccessor <ExpressionSyntax, ExpressionSyntax>(RefExpressionSyntaxType, nameof(Expression));
     WithRefKeywordAccessor  = LightupHelpers.CreateSyntaxWithPropertyAccessor <ExpressionSyntax, SyntaxToken>(RefExpressionSyntaxType, nameof(RefKeyword));
     WithExpressionAccessor  = LightupHelpers.CreateSyntaxWithPropertyAccessor <ExpressionSyntax, ExpressionSyntax>(RefExpressionSyntaxType, nameof(Expression));
 }

示例#20

 static TupleElementSyntaxWrapper()
 {
     TupleElementSyntaxType = typeof(CSharpSyntaxNode).GetTypeInfo().Assembly.GetType(TupleElementSyntaxTypeName);
     IdentifierAccessor     = LightupHelpers.CreateSyntaxPropertyAccessor <CSharpSyntaxNode, SyntaxToken>(TupleElementSyntaxType, nameof(Identifier));
     TypeAccessor           = LightupHelpers.CreateSyntaxPropertyAccessor <CSharpSyntaxNode, TypeSyntax>(TupleElementSyntaxType, nameof(Type));
     WithIdentifierAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor <CSharpSyntaxNode, SyntaxToken>(TupleElementSyntaxType, nameof(Identifier));
     WithTypeAccessor       = LightupHelpers.CreateSyntaxWithPropertyAccessor <CSharpSyntaxNode, TypeSyntax>(TupleElementSyntaxType, nameof(Type));
 }

示例#21

 static IWhileLoopOperationWrapper()
 {
     WrappedType              = OperationWrapperHelper.GetWrappedType(typeof(IWhileLoopOperationWrapper));
     ConditionAccessor        = LightupHelpers.CreateOperationPropertyAccessor <IOperation, IOperation>(WrappedType, nameof(Condition));
     ConditionIsTopAccessor   = LightupHelpers.CreateOperationPropertyAccessor <IOperation, bool>(WrappedType, nameof(ConditionIsTop));
     ConditionIsUntilAccessor = LightupHelpers.CreateOperationPropertyAccessor <IOperation, bool>(WrappedType, nameof(ConditionIsUntil));
     IgnoredConditionAccessor = LightupHelpers.CreateOperationPropertyAccessor <IOperation, IOperation>(WrappedType, nameof(IgnoredCondition));
 }

示例#22

文件： LocalDeclarationStatementSyntaxExtensions.cs 项目： zhuthree/StyleCopAnalyzers

        static LocalDeclarationStatementSyntaxExtensions()
        {
            AwaitKeywordAccessor = LightupHelpers.CreateSyntaxPropertyAccessor <LocalDeclarationStatementSyntax, SyntaxToken>(typeof(LocalDeclarationStatementSyntax), nameof(AwaitKeyword));
            UsingKeywordAccessor = LightupHelpers.CreateSyntaxPropertyAccessor <LocalDeclarationStatementSyntax, SyntaxToken>(typeof(LocalDeclarationStatementSyntax), nameof(UsingKeyword));

            WithAwaitKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor <LocalDeclarationStatementSyntax, SyntaxToken>(typeof(LocalDeclarationStatementSyntax), nameof(AwaitKeyword));
            WithUsingKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor <LocalDeclarationStatementSyntax, SyntaxToken>(typeof(LocalDeclarationStatementSyntax), nameof(UsingKeyword));
        }

示例#23

 static SubpatternSyntaxWrapper()
 {
     WrappedType           = SyntaxWrapperHelper.GetWrappedType(typeof(SubpatternSyntaxWrapper));
     NameColonAccessor     = LightupHelpers.CreateSyntaxPropertyAccessor <CSharpSyntaxNode, NameColonSyntax>(WrappedType, nameof(NameColon));
     PatternAccessor       = LightupHelpers.CreateSyntaxPropertyAccessor <CSharpSyntaxNode, CSharpSyntaxNode>(WrappedType, nameof(Pattern));
     WithNameColonAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor <CSharpSyntaxNode, NameColonSyntax>(WrappedType, nameof(NameColon));
     WithPatternAccessor   = LightupHelpers.CreateSyntaxWithPropertyAccessor <CSharpSyntaxNode, CSharpSyntaxNode>(WrappedType, nameof(Pattern));
 }

示例#24

文件： RefTypeSyntaxWrapper.cs 项目： scott-xu/StyleCopAnalyzers

 static RefTypeSyntaxWrapper()
 {
     RefTypeSyntaxType      = typeof(CSharpSyntaxNode).GetTypeInfo().Assembly.GetType(RefTypeSyntaxTypeName);
     RefKeywordAccessor     = LightupHelpers.CreateSyntaxPropertyAccessor <TypeSyntax, SyntaxToken>(RefTypeSyntaxType, nameof(RefKeyword));
     TypeAccessor           = LightupHelpers.CreateSyntaxPropertyAccessor <TypeSyntax, TypeSyntax>(RefTypeSyntaxType, nameof(Type));
     WithRefKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor <TypeSyntax, SyntaxToken>(RefTypeSyntaxType, nameof(RefKeyword));
     WithTypeAccessor       = LightupHelpers.CreateSyntaxWithPropertyAccessor <TypeSyntax, TypeSyntax>(RefTypeSyntaxType, nameof(Type));
 }

示例#25

文件： RefTypeSyntaxWrapper.cs 项目： TechSmith/StyleCopAnalyzers

 static RefTypeSyntaxWrapper()
 {
     WrappedType            = WrapperHelper.GetWrappedType(typeof(RefTypeSyntaxWrapper));
     RefKeywordAccessor     = LightupHelpers.CreateSyntaxPropertyAccessor <TypeSyntax, SyntaxToken>(WrappedType, nameof(RefKeyword));
     TypeAccessor           = LightupHelpers.CreateSyntaxPropertyAccessor <TypeSyntax, TypeSyntax>(WrappedType, nameof(Type));
     WithRefKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor <TypeSyntax, SyntaxToken>(WrappedType, nameof(RefKeyword));
     WithTypeAccessor       = LightupHelpers.CreateSyntaxWithPropertyAccessor <TypeSyntax, TypeSyntax>(WrappedType, nameof(Type));
 }

示例#26

文件： IUsingOperationWrapper.g.cs 项目： wdolek/StyleCopAnalyzers

 static IUsingOperationWrapper()
 {
     WrappedType            = OperationWrapperHelper.GetWrappedType(typeof(IUsingOperationWrapper));
     ResourcesAccessor      = LightupHelpers.CreateOperationPropertyAccessor <IOperation, IOperation>(WrappedType, nameof(Resources));
     BodyAccessor           = LightupHelpers.CreateOperationPropertyAccessor <IOperation, IOperation>(WrappedType, nameof(Body));
     LocalsAccessor         = LightupHelpers.CreateOperationPropertyAccessor <IOperation, ImmutableArray <ILocalSymbol> >(WrappedType, nameof(Locals));
     IsAsynchronousAccessor = LightupHelpers.CreateOperationPropertyAccessor <IOperation, bool>(WrappedType, nameof(IsAsynchronous));
 }

示例#27

文件： VarPatternSyntaxWrapper.cs 项目： smichtch/StyleCopAnalyzers

        static VarPatternSyntaxWrapper()
        {
            WrappedType         = WrapperHelper.GetWrappedType(typeof(VarPatternSyntaxWrapper));
            VarKeywordAccessor  = LightupHelpers.CreateSyntaxPropertyAccessor <CSharpSyntaxNode, SyntaxToken>(WrappedType, nameof(VarKeyword));
            DesignationAccessor = LightupHelpers.CreateSyntaxPropertyAccessor <CSharpSyntaxNode, CSharpSyntaxNode>(WrappedType, nameof(Designation));

            WithVarKeywordAccessor  = LightupHelpers.CreateSyntaxWithPropertyAccessor <CSharpSyntaxNode, SyntaxToken>(WrappedType, nameof(VarKeyword));
            WithDesignationAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor <CSharpSyntaxNode, CSharpSyntaxNode>(WrappedType, nameof(Designation));
        }

示例#28

 static IRecursivePatternOperationWrapper()
 {
     WrappedType                       = OperationWrapperHelper.GetWrappedType(typeof(IRecursivePatternOperationWrapper));
     MatchedTypeAccessor               = LightupHelpers.CreateOperationPropertyAccessor <IOperation, ITypeSymbol>(WrappedType, nameof(MatchedType));
     DeconstructSymbolAccessor         = LightupHelpers.CreateOperationPropertyAccessor <IOperation, ISymbol>(WrappedType, nameof(DeconstructSymbol));
     DeconstructionSubpatternsAccessor = LightupHelpers.CreateOperationListPropertyAccessor <IOperation>(WrappedType, nameof(DeconstructionSubpatterns));
     PropertySubpatternsAccessor       = LightupHelpers.CreateOperationListPropertyAccessor <IOperation>(WrappedType, nameof(PropertySubpatterns));
     DeclaredSymbolAccessor            = LightupHelpers.CreateOperationPropertyAccessor <IOperation, ISymbol>(WrappedType, nameof(DeclaredSymbol));
 }

示例#29

文件： IIncrementOrDecrementOperationWrapper.g.cs 项目： zhuthree/StyleCopAnalyzers

 static IIncrementOrDecrementOperationWrapper()
 {
     WrappedType            = OperationWrapperHelper.GetWrappedType(typeof(IIncrementOrDecrementOperationWrapper));
     IsPostfixAccessor      = LightupHelpers.CreateOperationPropertyAccessor <IOperation, bool>(WrappedType, nameof(IsPostfix));
     IsLiftedAccessor       = LightupHelpers.CreateOperationPropertyAccessor <IOperation, bool>(WrappedType, nameof(IsLifted));
     IsCheckedAccessor      = LightupHelpers.CreateOperationPropertyAccessor <IOperation, bool>(WrappedType, nameof(IsChecked));
     TargetAccessor         = LightupHelpers.CreateOperationPropertyAccessor <IOperation, IOperation>(WrappedType, nameof(Target));
     OperatorMethodAccessor = LightupHelpers.CreateOperationPropertyAccessor <IOperation, IMethodSymbol>(WrappedType, nameof(OperatorMethod));
 }

示例#30

文件： ICatchClauseOperationWrapper.g.cs 项目： zhuthree/StyleCopAnalyzers

 static ICatchClauseOperationWrapper()
 {
     WrappedType = OperationWrapperHelper.GetWrappedType(typeof(ICatchClauseOperationWrapper));
     ExceptionDeclarationOrExpressionAccessor = LightupHelpers.CreateOperationPropertyAccessor <IOperation, IOperation>(WrappedType, nameof(ExceptionDeclarationOrExpression));
     ExceptionTypeAccessor = LightupHelpers.CreateOperationPropertyAccessor <IOperation, ITypeSymbol>(WrappedType, nameof(ExceptionType));
     LocalsAccessor        = LightupHelpers.CreateOperationPropertyAccessor <IOperation, ImmutableArray <ILocalSymbol> >(WrappedType, nameof(Locals));
     FilterAccessor        = LightupHelpers.CreateOperationPropertyAccessor <IOperation, IOperation>(WrappedType, nameof(Filter));
     HandlerAccessor       = LightupHelpers.CreateOperationPropertyAccessor <IOperation, IOperation>(WrappedType, nameof(Handler));
 }