From edc4f72570b5c19bea295b47ea3f4bc15b0f5cc7 Mon Sep 17 00:00:00 2001 From: Sam Harwell Date: Fri, 13 Nov 2020 20:58:54 -0800 Subject: [PATCH 01/18] Add Syntax.xml from dotnet/roslyn@4c195c3a --- .../StyleCop.Analyzers/Lightup/Syntax.xml | 4848 +++++++++++++++++ .../StyleCop.Analyzers.csproj | 1 + 2 files changed, 4849 insertions(+) create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/Syntax.xml diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/Syntax.xml b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/Syntax.xml new file mode 100644 index 0000000000..f24059e17a --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/Syntax.xml @@ -0,0 +1,4848 @@ + + + + + + + + + + + + + Provides the base class from which the classes that represent name syntax nodes are derived. This is an abstract class. + + + + + + SyntaxToken representing the identifier of the simple name. + + + + + Provides the base class from which the classes that represent simple name syntax nodes are derived. This is an abstract class. + + + + + + + + + SyntaxToken representing the keyword for the kind of the identifier name. + + + + Class which represents the syntax node for identifier name. + + + Creates an IdentifierNameSyntax node. + + + + + + + NameSyntax node representing the name on the left side of the dot token of the qualified name. + + + + + + SyntaxToken representing the dot. + + + + + SimpleNameSyntax node representing the name on the right side of the dot token of the qualified name. + + + + Class which represents the syntax node for qualified name. + + + Creates a QualifiedNameSyntax node. + + + + + + + + SyntaxToken representing the name of the identifier of the generic name. + + + + + TypeArgumentListSyntax node representing the list of type arguments of the generic name. + + + + Class which represents the syntax node for generic name. + + + Creates a GenericNameSyntax node. + + + + + + + + SyntaxToken representing less than. + + + + + SeparatedSyntaxList of TypeSyntax node representing the type arguments. + + + + + + SyntaxToken representing greater than. + + + + Class which represents the syntax node for type argument list. + + + Creates a TypeArgumentListSyntax node. + + + + + + + IdentifierNameSyntax node representing the name of the alias + + + + + + SyntaxToken representing colon colon. + + + + + SimpleNameSyntax node representing the name that is being alias qualified. + + + + Class which represents the syntax node for alias qualified name. + + + Creates an AliasQualifiedNameSyntax node. + + + + + + Provides the base class from which the classes that represent type syntax nodes are derived. This is an abstract class. + + + + + + + + + + + + + + + + + + + + + + + SyntaxToken which represents the keyword corresponding to the predefined type. + + + + Class which represents the syntax node for predefined types. + + + Creates a PredefinedTypeSyntax node. + + + + + + + TypeSyntax node representing the type of the element of the array. + + + + + SyntaxList of ArrayRankSpecifierSyntax nodes representing the list of rank specifiers for the array. + + + + Class which represents the syntax node for the array type. + + + Creates an ArrayTypeSyntax node. + + + + + + + + + + + + + + + + + TypeSyntax node that represents the element type of the pointer. + + + + + + SyntaxToken representing the asterisk. + + + + Class which represents the syntax node for pointer type. + + + Creates a PointerTypeSyntax node. + + + + + + + + SyntaxToken representing the delegate keyword. + + + + + + SyntaxToken representing the asterisk. + + + + + Node representing the optional calling convention. + + + + + List of the parameter types and return type of the function pointer. + + + + + + Function pointer parameter list syntax. + + + + + + SyntaxToken representing the less than token. + + + + + SeparatedSyntaxList of ParameterSyntaxes representing the list of parameters and return type. + + + + + + SyntaxToken representing the greater than token. + + + + + + Function pointer calling convention syntax. + + + + + + + SyntaxToken representing whether the calling convention is managed or unmanaged. + + + + + Optional list of identifiers that will contribute to an unmanaged calling convention. + + + + + + Function pointer calling convention syntax. + + + + + + SyntaxToken representing open bracket. + + + + + SeparatedSyntaxList of calling convention identifiers. + + + + + + SyntaxToken representing close bracket. + + + + + + Individual function pointer unmanaged calling convention. + + + + + + SyntaxToken representing the calling convention identifier. + + + + + + + + TypeSyntax node representing the type of the element. + + + + + + SyntaxToken representing the question mark. + + + + Class which represents the syntax node for a nullable type. + + + Creates a NullableTypeSyntax node. + + + + + + + + SyntaxToken representing the open parenthesis. + + + + + + + SyntaxToken representing the close parenthesis. + + + + Class which represents the syntax node for tuple type. + + + Creates a TupleTypeSyntax node. + + + + + Tuple type element. + + + + + Gets the type of the tuple element. + + + + + Gets the name of the tuple element. + + + + + + + + + + SyntaxToken representing the omitted type argument. + + + + Class which represents a placeholder in the type argument list of an unbound generic type. + + + Creates an OmittedTypeArgumentSyntax node. + + + + + The ref modifier of a method's return value or a local. + + + + + + + + + Gets the optional "readonly" keyword. + + + + + + + + + Provides the base class from which the classes that represent expression syntax nodes are derived. This is an abstract class. + + + + + + + + SyntaxToken representing the open parenthesis. + + + + + ExpressionSyntax node representing the expression enclosed within the parenthesis. + + + + + + SyntaxToken representing the close parenthesis. + + + + Class which represents the syntax node for parenthesized expression. + + + Creates a ParenthesizedExpressionSyntax node. + + + + + + + + SyntaxToken representing the open parenthesis. + + + + + SeparatedSyntaxList of ArgumentSyntax representing the list of arguments. + + + + + + SyntaxToken representing the close parenthesis. + + + + Class which represents the syntax node for tuple expression. + + + Creates a TupleExpressionSyntax node. + + + + + + + + + + + + + + + + + + + + + + " + + SyntaxToken representing the kind of the operator of the prefix unary expression. + + + + + ExpressionSyntax representing the operand of the prefix unary expression. + + + + Class which represents the syntax node for prefix unary expression. + + + Creates a PrefixUnaryExpressionSyntax node. + + + + + + + + SyntaxToken representing the kind "await" keyword. + + + + + ExpressionSyntax representing the operand of the "await" operator. + + + + Class which represents the syntax node for an "await" expression. + + + Creates an AwaitExpressionSyntax node. + + + + + + + + + ExpressionSyntax representing the operand of the postfix unary expression. + + + + + + + + SyntaxToken representing the kind of the operator of the postfix unary expression. + + + + Class which represents the syntax node for postfix unary expression. + + + Creates a PostfixUnaryExpressionSyntax node. + + + + + + + + ExpressionSyntax node representing the object that the member belongs to. + + + + + + + SyntaxToken representing the kind of the operator in the member access expression. + + + + + SimpleNameSyntax node representing the member being accessed. + + + + Class which represents the syntax node for member access expression. + + + Creates a MemberAccessExpressionSyntax node. + + + + + + + ExpressionSyntax node representing the object conditionally accessed. + + + + + + SyntaxToken representing the question mark. + + + + + ExpressionSyntax node representing the access expression to be executed when the object is not null. + + + + Class which represents the syntax node for conditional access expression. + + + Creates a ConditionalAccessExpressionSyntax node. + + + + + + + + SyntaxToken representing dot. + + + + + SimpleNameSyntax node representing the member being bound to. + + + + Class which represents the syntax node for member binding expression. + + + Creates a MemberBindingExpressionSyntax node. + + + + + + + BracketedArgumentListSyntax node representing the list of arguments of the element binding expression. + + + + Class which represents the syntax node for element binding expression. + + + Creates an ElementBindingExpressionSyntax node. + + + + + + + ExpressionSyntax node representing the expression on the left of the range operator. + + + + + + SyntaxToken representing the operator of the range expression. + + + + + ExpressionSyntax node representing the expression on the right of the range operator. + + + + Class which represents the syntax node for a range expression. + + + Creates an RangeExpressionSyntax node. + + + + + + + BracketedArgumentListSyntax node representing the list of arguments of the implicit element access expression. + + + + Class which represents the syntax node for implicit element access expression. + + + Creates an ImplicitElementAccessSyntax node. + + + + + + + + + + + + + + + + + + + + + + + + + + + ExpressionSyntax node representing the expression on the left of the binary operator. + + + + + + + + + + + + + + + + + + + + + + + + + + SyntaxToken representing the operator of the binary expression. + + + + + ExpressionSyntax node representing the expression on the right of the binary operator. + + + + Class which represents an expression that has a binary operator. + + + Creates a BinaryExpressionSyntax node. + + + + + + + + + + + + + + + + + + ExpressionSyntax node representing the expression on the left of the assignment operator. + + + + + + + + + + + + + + + + + SyntaxToken representing the operator of the assignment expression. + + + + + ExpressionSyntax node representing the expression on the right of the assignment operator. + + + + Class which represents an expression that has an assignment operator. + + + Creates an AssignmentExpressionSyntax node. + + + + + + + ExpressionSyntax node representing the condition of the conditional expression. + + + + + + SyntaxToken representing the question mark. + + + + + ExpressionSyntax node representing the expression to be executed when the condition is true. + + + + + + SyntaxToken representing the colon. + + + + + ExpressionSyntax node representing the expression to be executed when the condition is false. + + + + Class which represents the syntax node for conditional expression. + + + Creates a ConditionalExpressionSyntax node. + + + + + Provides the base class from which the classes that represent instance expression syntax nodes are derived. This is an abstract class. + + + + + + + + SyntaxToken representing the this keyword. + + + + Class which represents the syntax node for a this expression. + + + Creates a ThisExpressionSyntax node. + + + + + + + + SyntaxToken representing the base keyword. + + + + Class which represents the syntax node for a base expression. + + + Creates a BaseExpressionSyntax node. + + + + + + + + + + + + + + + + + + + + + + SyntaxToken representing the keyword corresponding to the kind of the literal expression. + + + + Class which represents the syntax node for a literal expression. + + + Creates a LiteralExpressionSyntax node. + + + + + + + + SyntaxToken representing the MakeRefKeyword. + + + + + + SyntaxToken representing open parenthesis. + + + + + Argument of the primary function. + + + + + + SyntaxToken representing close parenthesis. + + + + Class which represents the syntax node for MakeRef expression. + + + Creates a MakeRefExpressionSyntax node. + + + + + + + + SyntaxToken representing the RefTypeKeyword. + + + + + + SyntaxToken representing open parenthesis. + + + + + Argument of the primary function. + + + + + + SyntaxToken representing close parenthesis. + + + + Class which represents the syntax node for RefType expression. + + + Creates a RefTypeExpressionSyntax node. + + + + + + + + SyntaxToken representing the RefValueKeyword. + + + + + + SyntaxToken representing open parenthesis. + + + + + Typed reference expression. + + + + + + Comma separating the arguments. + + + + + The type of the value. + + + + + + SyntaxToken representing close parenthesis. + + + + Class which represents the syntax node for RefValue expression. + + + Creates a RefValueExpressionSyntax node. + + + + + + + + + + SyntaxToken representing the checked or unchecked keyword. + + + + + + SyntaxToken representing open parenthesis. + + + + + Argument of the primary function. + + + + + + SyntaxToken representing close parenthesis. + + + + Class which represents the syntax node for Checked or Unchecked expression. + + + Creates a CheckedExpressionSyntax node. + + + + + + + + SyntaxToken representing the DefaultKeyword. + + + + + + SyntaxToken representing open parenthesis. + + + + + Argument of the primary function. + + + + + + SyntaxToken representing close parenthesis. + + + + Class which represents the syntax node for Default expression. + + + Creates a DefaultExpressionSyntax node. + + + + + + + + SyntaxToken representing the TypeOfKeyword. + + + + + + SyntaxToken representing open parenthesis. + + + + + The expression to return type of. + + + + + + SyntaxToken representing close parenthesis. + + + + Class which represents the syntax node for TypeOf expression. + + + Creates a TypeOfExpressionSyntax node. + + + + + + + + SyntaxToken representing the SizeOfKeyword. + + + + + + SyntaxToken representing open parenthesis. + + + + + Argument of the primary function. + + + + + + SyntaxToken representing close parenthesis. + + + + Class which represents the syntax node for SizeOf expression. + + + Creates a SizeOfExpressionSyntax node. + + + + + + + ExpressionSyntax node representing the expression part of the invocation. + + + + + ArgumentListSyntax node representing the list of arguments of the invocation expression. + + + + Class which represents the syntax node for invocation expression. + + + Creates an InvocationExpressionSyntax node. + + + + + + + ExpressionSyntax node representing the expression which is accessing the element. + + + + + BracketedArgumentListSyntax node representing the list of arguments of the element access expression. + + + + Class which represents the syntax node for element access expression. + + + Creates an ElementAccessExpressionSyntax node. + + + + + + SeparatedSyntaxList of ArgumentSyntax nodes representing the list of arguments. + + + + Provides the base class from which the classes that represent argument list syntax nodes are derived. This is an abstract class. + + + + + + + + SyntaxToken representing open parenthesis. + + + + + SeparatedSyntaxList of ArgumentSyntax representing the list of arguments. + + + + + + SyntaxToken representing close parenthesis. + + + + Class which represents the syntax node for the list of arguments. + + + Creates an ArgumentListSyntax node. + + + + + + + + SyntaxToken representing open bracket. + + + + + SeparatedSyntaxList of ArgumentSyntax representing the list of arguments. + + + + + + SyntaxToken representing close bracket. + + + + Class which represents the syntax node for bracketed argument list. + + + Creates a BracketedArgumentListSyntax node. + + + + + + + NameColonSyntax node representing the optional name arguments. + + + + + + + + SyntaxToken representing the optional ref or out keyword. + + + + + ExpressionSyntax node representing the argument. + + + + Class which represents the syntax node for argument. + + + Creates an ArgumentSyntax node. + + + + + + + + IdentifierNameSyntax representing the identifier name. + + + + + + SyntaxToken representing colon. + + + + Class which represents the syntax node for name colon syntax. + + + Creates a NameColonSyntax node. + + + + + + + + Declaration representing the variable declared in an out parameter or deconstruction. + + + + Class which represents the syntax node for the variable declaration in an out var declaration or a deconstruction declaration. + + + Creates a DeclarationExpression node. + + + + + + + + SyntaxToken representing the open parenthesis. + + + + + TypeSyntax node representing the type to which the expression is being cast. + + + + + + SyntaxToken representing the close parenthesis. + + + + + ExpressionSyntax node representing the expression that is being casted. + + + + Class which represents the syntax node for cast expression. + + + Creates a CastExpressionSyntax node. + + + + + Provides the base class from which the classes that represent anonymous function expressions are derived. + + + + + + + BlockSyntax node representing the body of the anonymous function. + Only one of Block or ExpressionBody will be non-null. + + + + + + + ExpressionSyntax node representing the body of the anonymous function. + Only one of Block or ExpressionBody will be non-null. + + + + + + + + + + + + SyntaxToken representing the delegate keyword. + + + + + List of parameters of the anonymous method expression, or null if there no parameters are specified. + + + + + + BlockSyntax node representing the body of the anonymous function. + This will never be null. + + + + + + + Inherited from AnonymousFunctionExpressionSyntax, but not used for + AnonymousMethodExpressionSyntax. This will always be null. + + + + + Class which represents the syntax node for anonymous method expression. + + + Creates an AnonymousMethodExpressionSyntax node. + + + + + Provides the base class from which the classes that represent lambda expressions are derived. + + + + + + SyntaxToken representing equals greater than. + + + + + + + + + + ParameterSyntax node representing the parameter of the lambda expression. + + + + + + + SyntaxToken representing equals greater than. + + + + + + + BlockSyntax node representing the body of the lambda. + Only one of Block or ExpressionBody will be non-null. + + + + + + + ExpressionSyntax node representing the body of the lambda. + Only one of Block or ExpressionBody will be non-null. + + + + + + Class which represents the syntax node for a simple lambda expression. + + + Creates a SimpleLambdaExpressionSyntax node. + + + + + + + + + + + + + + + ParameterListSyntax node representing the list of parameters for the lambda expression. + + + + + + + SyntaxToken representing equals greater than. + + + + + + + BlockSyntax node representing the body of the lambda. + Only one of Block or ExpressionBody will be non-null. + + + + + + + ExpressionSyntax node representing the body of the lambda. + Only one of Block or ExpressionBody will be non-null. + + + + + + Class which represents the syntax node for parenthesized lambda expression. + + + Creates a ParenthesizedLambdaExpressionSyntax node. + + + + + + + + + + + + SyntaxToken representing the open brace. + + + + + SeparatedSyntaxList of ExpressionSyntax representing the list of expressions in the initializer expression. + + + + + + SyntaxToken representing the close brace. + + + + Class which represents the syntax node for initializer expression. + + + Creates an InitializerExpressionSyntax node. + + + + + + + SyntaxToken representing the new keyword. + + + + + ArgumentListSyntax representing the list of arguments passed as part of the object creation expression. + + + + + InitializerExpressionSyntax representing the initializer expression for the object being created. + + + + + + + + + SyntaxToken representing the new keyword. + + + + + ArgumentListSyntax representing the list of arguments passed as part of the object creation expression. + + + + + InitializerExpressionSyntax representing the initializer expression for the object being created. + + + + Class which represents the syntax node for implicit object creation expression. + + + Creates an ImplicitObjectCreationExpressionSyntax node. + + + + + + + + SyntaxToken representing the new keyword. + + + + + TypeSyntax representing the type of the object being created. + + + + + ArgumentListSyntax representing the list of arguments passed as part of the object creation expression. + + + + + InitializerExpressionSyntax representing the initializer expression for the object being created. + + + + Class which represents the syntax node for object creation expression. + + + Creates an ObjectCreationExpressionSyntax node. + + + + + + + + + + + InitializerExpressionSyntax representing the initializer expression for the with expression. + + + + + + + + NameEqualsSyntax representing the optional name of the member being initialized. + + + + + ExpressionSyntax representing the value the member is initialized with. + + + + Creates an AnonymousObjectMemberDeclaratorSyntax node. + + + + + + + + SyntaxToken representing the new keyword. + + + + + + SyntaxToken representing the open brace. + + + + + SeparatedSyntaxList of AnonymousObjectMemberDeclaratorSyntax representing the list of object member initializers. + + + + + + SyntaxToken representing the close brace. + + + + Class which represents the syntax node for anonymous object creation expression. + + + Creates an AnonymousObjectCreationExpressionSyntax node. + + + + + + + + SyntaxToken representing the new keyword. + + + + + ArrayTypeSyntax node representing the type of the array. + + + + + InitializerExpressionSyntax node representing the initializer of the array creation expression. + + + + Class which represents the syntax node for array creation expression. + + + Creates an ArrayCreationExpressionSyntax node. + + + + + + + + SyntaxToken representing the new keyword. + + + + + + SyntaxToken representing the open bracket. + + + + + SyntaxList of SyntaxToken representing the commas in the implicit array creation expression. + + + + + + SyntaxToken representing the close bracket. + + + + + InitializerExpressionSyntax representing the initializer expression of the implicit array creation expression. + + + + Class which represents the syntax node for implicit array creation expression. + + + Creates an ImplicitArrayCreationExpressionSyntax node. + + + + + + + + SyntaxToken representing the stackalloc keyword. + + + + + TypeSyntax node representing the type of the stackalloc array. + + + + + InitializerExpressionSyntax node representing the initializer of the stackalloc array creation expression. + + + + Class which represents the syntax node for stackalloc array creation expression. + + + Creates a StackAllocArrayCreationExpressionSyntax node. + + + + + + + + SyntaxToken representing the stackalloc keyword. + + + + + + SyntaxToken representing the open bracket. + + + + + + SyntaxToken representing the close bracket. + + + + + InitializerExpressionSyntax representing the initializer expression of the implicit stackalloc array creation expression. + + + + Class which represents the syntax node for implicit stackalloc array creation expression. + + + Creates an ImplicitStackAllocArrayCreationExpressionSyntax node. + + + + + + + + + + + + + + + + + + + + + + + + + + Gets the identifier. + + + + + + + + + + + + + + + + Gets the identifier. + + + + + + + + + + + + + + + + + Gets the identifier. + + + + + + + + + + + + + + + + + + + + + + + + + Gets the identifier. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Gets the identifier. + + + + + + + + + + + SyntaxToken representing the omitted array size expression. + + + + Class which represents a placeholder in an array size list. + + + Creates an OmittedArraySizeExpressionSyntax node. + + + + + + + + + The first part of an interpolated string, $" or $@" + + + + + List of parts of the interpolated string, each one is either a literal part or an interpolation. + + + + + + The closing quote of the interpolated string. + + + + + + + + ExpressionSyntax node representing the expression on the left of the "is" operator. + + + + + + + + PatternSyntax node representing the pattern on the right of the "is" operator. + + + + Class which represents a simple pattern-matching expression using the "is" keyword. + + + Creates an IsPatternExpressionSyntax node. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + ExpressionSyntax node representing the constant expression. + + + + + + + + + + + + + + + + + + + + + + + + + + SyntaxToken representing the operator of the relational pattern. + + + + + + + + + The type for the type pattern. + + + + + + + + + + + + + + + + + + + + + + + + + + + + The text contents of a part of the interpolated string. + + + + + + + + + + + + + + + + + + + + + + + + + + + The text contents of the format specifier for an interpolation. + + + + + + + + Always empty on a global statement. + + + Always empty on a global statement. + + + + + + Represents the base class for all statements syntax classes. + + + + + + + + + + + + + + + + + + + + + + Gets the identifier. + + + + + + + + + + + + + Gets the optional semicolon token. + + + + + + + + + + + + + + + + + + + Gets the modifier list. + + + + + + + + + + + + + + + + + + + Gets the identifier. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Gets the identifier. + + + + + + + Gets a SyntaxToken that represents the colon following the statement's label. + + + + + Represents a labeled statement syntax. + + + Creates a LabeledStatementSyntax node + + + + + + + + + + + + Gets a SyntaxToken that represents the goto keyword. + + + + + + + + + Gets a SyntaxToken that represents the case or default keywords if any exists. + + + + + + + Gets a constant expression for a goto case statement. + + + + + + + + Gets a SyntaxToken that represents the semi-colon at the end of the statement. + + + + + + Represents a goto statement syntax + + + + + Creates a GotoStatementSyntax node. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Gets the identifier. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + The variable(s) of the loop. In correct code this is a tuple + literal, declaration expression with a tuple designator, or + a discard syntax in the form of a simple identifier. In broken + code it could be something else. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Gets a SyntaxToken that represents the if keyword. + + + + + + + + Gets a SyntaxToken that represents the open parenthesis before the if statement's condition expression. + + + + + + + Gets an ExpressionSyntax that represents the condition of the if statement. + + + + + + + + Gets a SyntaxToken that represents the close parenthesis after the if statement's condition expression. + + + + + + + Gets a StatementSyntax the represents the statement to be executed when the condition is true. + + + + + + + Gets an ElseClauseSyntax that represents the statement to be executed when the condition is false if such statement exists. + + + + + + Represents an if statement syntax. + + + + Creates an IfStatementSyntax node + + + + + + + + + Gets a syntax token + + + + + + Represents an else statement syntax. + + + Creates a ElseClauseSyntax node + + + + + + + + + + + Gets a SyntaxToken that represents the switch keyword. + + + + + + + + Gets a SyntaxToken that represents the open parenthesis preceding the switch governing expression. + + + + + + + Gets an ExpressionSyntax representing the expression of the switch statement. + + + + + + + + Gets a SyntaxToken that represents the close parenthesis following the switch governing expression. + + + + + + + + Gets a SyntaxToken that represents the open braces preceding the switch sections. + + + + + + + Gets a SyntaxList of SwitchSectionSyntax's that represents the switch sections of the switch statement. + + + + + + + + Gets a SyntaxToken that represents the open braces following the switch sections. + + + + + Represents a switch statement syntax. + + + Creates a SwitchStatementSyntax node. + + + + + + + + Gets a SyntaxList of SwitchLabelSyntax's the represents the possible labels that control can transfer to within the section. + + + + + + + Gets a SyntaxList of StatementSyntax's the represents the statements to be executed when control transfer to a label the belongs to the section. + + + + + Represents a switch section syntax of a switch statement. + + + Creates a SwitchSectionSyntax node. + + + + + + + Gets a SyntaxToken that represents a case or default keyword that belongs to a switch label. + + + + + + + + Gets a SyntaxToken that represents the colon that terminates the switch label. + + + + + Represents a switch label within a switch statement. + + + + + + + + Gets the case keyword token. + + + + + + Gets a PatternSyntax that represents the pattern that gets matched for the case label. + + + + + + + Represents a case label within a switch statement. + + + Creates a CaseMatchLabelSyntax node. + + + + + + + + Gets the case keyword token. + + + + + + Gets an ExpressionSyntax that represents the constant expression that gets matched for the case label. + + + + + + Represents a case label within a switch statement. + + + Creates a CaseSwitchLabelSyntax node. + + + + + + + + Gets the default keyword token. + + + + + Represents a default label within a switch statement. + + + Creates a DefaultSwitchLabelSyntax node. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Gets the attribute declaration list. + + + + + + + + + + + + + SyntaxToken representing the extern keyword. + + + + + + SyntaxToken representing the alias keyword. + + + + + Gets the identifier. + + + + + + + SyntaxToken representing the semicolon token. + + + + + Represents an ExternAlias directive syntax, e.g. "extern alias MyAlias;" with specifying "/r:MyAlias=SomeAssembly.dll " on the compiler command line. + + + + Creates an ExternAliasDirectiveSyntax node + + + + + + + + + + + + + + + + + + + Member declaration syntax. + + + + Gets the attribute declaration list. + + + + + Gets the modifier list. + + + + + + + + + + + + + + + + + + + + + + + Gets the optional semicolon token. + + + + + + + Class representing one or more attributes applied to a language construct. + + + + + + Gets the open bracket token. + + + + + Gets the optional construct targeted by the attribute. + + + + + Gets the attribute declaration list. + + + + + + Gets the close bracket token. + + + + + + Class representing what language construct an attribute targets. + + + + + Gets the identifier. + + + + + + Gets the colon token. + + + + + + Attribute syntax. + + + + + Gets the name. + + + + + + + Attribute argument list syntax. + + + + + Gets the open paren token. + + + + + + Gets the arguments syntax list. + + + + + Gets the close paren token. + + + + + + + Attribute argument syntax. + + + + + + + + + Gets the expression. + + + + + + Class representing an identifier name followed by an equals token. + + + + + Gets the identifier name. + + + + + + + + + + Type parameter list syntax. + + + + + Gets the < token. + + + + + + Gets the parameter list. + + + + + Gets the > token. + + + + + + + Type parameter syntax. + + + + + Gets the attribute declaration list. + + + + + + + + + Gets the identifier. + + + + + + + Base class for type declaration syntax. + + + + Gets the identifier. + + + + + + Gets the base type list. + + + + + Gets the open brace token. + + + + + + Gets the close brace token. + + + + + + Gets the optional semicolon token. + + + + + + + Base class for type declaration syntax (class, struct, interface, record). + + + + Gets the type keyword token ("class", "struct", "interface", "record"). + + + + + + Gets the type constraint list. + + + + + Gets the member declarations. + + + + + + Class type declaration syntax. + + + + + + + Gets the class keyword token. + + + + + + + + + + + + + + + + + + + + + + + Struct type declaration syntax. + + + + + + + Gets the struct keyword token. + + + + + + + + + + + + + + + + + + + + + + + Interface type declaration syntax. + + + + + + + Gets the interface keyword token. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Enum type declaration syntax. + + + + + + + Gets the enum keyword token. + + + + + + + + + + + + + + Gets the members declaration list. + + + + + + + + Gets the optional semicolon token. + + + + + + + Delegate declaration syntax. + + + + + + + Gets the "delegate" keyword. + + + + + + Gets the return type. + + + + + Gets the identifier. + + + + + + + Gets the parameter list. + + + + + Gets the constraint clause list. + + + + + Gets the semicolon token. + + + + + + + + + + + Gets the identifier. + + + + + + + + Base list syntax. + + + + + Gets the colon token. + + + + + + Gets the base type references. + + + + + + + Provides the base class from which the classes that represent base type syntax nodes are derived. This is an abstract class. + + + + + + + + + + + + + + + + + + + + Type parameter constraint clause. + + + + + + + + Gets the identifier. + + + + + + Gets the colon token. + + + + + + Gets the constraints list. + + + + + + Base type for type parameter constraint syntax. + + + + + Constructor constraint syntax. + + + + + Gets the "new" keyword. + + + + + + Gets the open paren keyword. + + + + + + Gets the close paren keyword. + + + + + + + Class or struct constraint syntax. + + + + + + Gets the constraint keyword ("class" or "struct"). + + + + + + + + SyntaxToken representing the question mark. + + + + + + Type constraint syntax. + + + + + Gets the type syntax. + + + + + + Default constraint syntax. + + + + + Gets the "default" keyword. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Base type for method declaration syntax. + + + + Gets the parameter list. + + + + + + + + + Gets the optional semicolon token. + + + + + + + + + Method declaration syntax. + + + + + + + Gets the return type syntax. + + + + + + Gets the identifier. + + + + + + + + Gets the constraint clause list. + + + + + + + + + Gets the optional semicolon token. + + + + + + + + + + Operator declaration syntax. + + + + + + + Gets the return type. + + + + + Gets the "operator" keyword. + + + + + + Gets the operator token. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Gets the optional semicolon token. + + + + + + + + + + Conversion operator declaration syntax. + + + + + + + Gets the "implicit" or "explicit" token. + + + + + + + Gets the "operator" token. + + + + + + Gets the type. + + + + + + + + + + Gets the optional semicolon token. + + + + + + + + + Constructor declaration syntax. + + + + + + + Gets the identifier. + + + + + + + + + + + + Gets the optional semicolon token. + + + + + + + + + Constructor initializer syntax. + + + + + + Gets the colon token. + + + + + + Gets the "this" or "base" keyword. + + + + + + + + + Destructor declaration syntax. + + + + + + + Gets the tilde token. + + + + + + Gets the identifier. + + + + + + + + + + + Gets the optional semicolon token. + + + + + + + + + Base type for property declaration syntax. + + + + Gets the type syntax. + + + + + Gets the optional explicit interface specifier. + + + + + + + + + + + + + Gets the identifier. + + + + + + + + + + + + + + + + + + + The syntax for the expression body of an expression-bodied member. + + + + + + + + + + + + + + + + + + + Gets the identifier. + + + + + + + + + + + + + + + + + + + + + + Gets the parameter list. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Gets the attribute declaration list. + + + + + Gets the modifier list. + + + + + + + + + + + Gets the keyword token, or identifier if an erroneous accessor declaration. + + + + + + Gets the optional body block which may be empty, but it is null if there are no braces. + + + + + + Gets the optional expression body. + + + + + Gets the optional semicolon token. + + + + + + + + + Base type for parameter list syntax. + + + + Gets the parameter list. + + + + + + Parameter list syntax. + + + + + Gets the open paren token. + + + + + + + Gets the close paren token. + + + + + + + Parameter list syntax with surrounding brackets. + + + + + Gets the open bracket token. + + + + + + + Gets the close bracket token. + + + + + + + Base parameter syntax. + + + + Gets the attribute declaration list. + + + + + Gets the modifier list. + + + + + + + Parameter syntax. + + + + + Gets the attribute declaration list. + + + + + Gets the modifier list. + + + + + + Gets the identifier. + + + + + + + + + Parameter syntax. + + + + + Gets the attribute declaration list. + + + + + Gets the modifier list. + + + + + + n + + + + + + + + + + + + + + + + + + + + + + + A symbol referenced by a cref attribute (e.g. in a <see> or <seealso> documentation comment tag). + For example, the M in <see cref="M" />. + + + + + + + A symbol reference that definitely refers to a type. + For example, "int", "A::B", "A.B", "A<T>", but not "M()" (has parameter list) or "this" (indexer). + NOTE: TypeCrefSyntax, QualifiedCrefSyntax, and MemberCrefSyntax overlap. The syntax in a TypeCrefSyntax + will always be bound as type, so it's safer to use QualifiedCrefSyntax or MemberCrefSyntax if the symbol + might be a non-type member. + + + + + + + + + A symbol reference to a type or non-type member that is qualified by an enclosing type or namespace. + For example, cref="System.String.ToString()". + NOTE: TypeCrefSyntax, QualifiedCrefSyntax, and MemberCrefSyntax overlap. The syntax in a TypeCrefSyntax + will always be bound as type, so it's safer to use QualifiedCrefSyntax or MemberCrefSyntax if the symbol + might be a non-type member. + + + + + + + + + + + + + The unqualified part of a CrefSyntax. + For example, "ToString()" in "object.ToString()". + NOTE: TypeCrefSyntax, QualifiedCrefSyntax, and MemberCrefSyntax overlap. The syntax in a TypeCrefSyntax + will always be bound as type, so it's safer to use QualifiedCrefSyntax or MemberCrefSyntax if the symbol + might be a non-type member. + + + + + + + A MemberCrefSyntax specified by a name (an identifier, predefined type keyword, or an alias-qualified name, + with an optional type parameter list) and an optional parameter list. + For example, "M", "M<T>" or "M(int)". + Also, "A::B()" or "string()". + + + + + + + + + + A MemberCrefSyntax specified by a this keyword and an optional parameter list. + For example, "this" or "this[int]". + + + + + + + + + + + + A MemberCrefSyntax specified by an operator keyword, an operator symbol and an optional parameter list. + For example, "operator +" or "operator -[int]". + NOTE: the operator must be overloadable. + + + + + + + + + Gets the operator token. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + A MemberCrefSyntax specified by an implicit or explicit keyword, an operator keyword, a destination type, and an optional parameter list. + For example, "implicit operator int" or "explicit operator MyType(int)". + + + + + + + + + + + + + + + + + A list of cref parameters with surrounding punctuation. + Unlike regular parameters, cref parameters do not have names. + + + + + Gets the parameter list. + + + + + + + A parenthesized list of cref parameters. + + + + + + Gets the open paren token. + + + + + + + Gets the close paren token. + + + + + + + + A bracketed list of cref parameters. + + + + + + Gets the open bracket token. + + + + + + + Gets the close bracket token. + + + + + + + + An element of a BaseCrefParameterListSyntax. + Unlike a regular parameter, a cref parameter has only an optional ref or out keyword and a type - + there is no name and there are no attributes or other modifiers. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/StyleCop.Analyzers.csproj b/StyleCop.Analyzers/StyleCop.Analyzers/StyleCop.Analyzers.csproj index b71878104c..bafb2794e8 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/StyleCop.Analyzers.csproj +++ b/StyleCop.Analyzers/StyleCop.Analyzers/StyleCop.Analyzers.csproj @@ -34,6 +34,7 @@ + From 09bf4ab97876f5dd278e6f2150aaf5fa129ea216 Mon Sep 17 00:00:00 2001 From: Sam Harwell Date: Fri, 13 Nov 2020 22:24:13 -0800 Subject: [PATCH 02/18] Generate initial syntax wrapper members --- .../SyntaxLightupGenerator.cs | 261 ++++++++++++++++++ StyleCop.Analyzers/StyleCop.Analyzers.ruleset | 1 + ...ObjectCreationExpressionSyntaxWrapper.g.cs | 24 ++ .../BaseParameterSyntaxWrapper.g.cs | 24 ++ .../BinaryPatternSyntaxWrapper.g.cs | 24 ++ .../CasePatternSwitchLabelSyntaxWrapper.g.cs | 24 ++ .../CommonForEachStatementSyntaxWrapper.g.cs | 24 ++ .../ConstantPatternSyntaxWrapper.g.cs | 24 ++ .../DeclarationExpressionSyntaxWrapper.g.cs | 24 ++ .../DeclarationPatternSyntaxWrapper.g.cs | 24 ++ .../DefaultConstraintSyntaxWrapper.g.cs | 24 ++ .../DiscardDesignationSyntaxWrapper.g.cs | 24 ++ .../DiscardPatternSyntaxWrapper.g.cs | 24 ++ .../ExpressionOrPatternSyntaxWrapper.g.cs | 24 ++ ...ForEachVariableStatementSyntaxWrapper.g.cs | 24 ++ ...PointerCallingConventionSyntaxWrapper.g.cs | 24 ++ ...tionPointerParameterListSyntaxWrapper.g.cs | 24 ++ ...FunctionPointerParameterSyntaxWrapper.g.cs | 24 ++ .../FunctionPointerTypeSyntaxWrapper.g.cs | 24 ++ ...gedCallingConventionListSyntaxWrapper.g.cs | 24 ++ ...managedCallingConventionSyntaxWrapper.g.cs | 24 ++ ...ObjectCreationExpressionSyntaxWrapper.g.cs | 24 ++ ...cArrayCreationExpressionSyntaxWrapper.g.cs | 24 ++ .../IsPatternExpressionSyntaxWrapper.g.cs | 24 ++ .../LocalFunctionStatementSyntaxWrapper.g.cs | 24 ++ .../NullableDirectiveTriviaSyntaxWrapper.g.cs | 24 ++ .../ParenthesizedPatternSyntaxWrapper.g.cs | 24 ++ ...sizedVariableDesignationSyntaxWrapper.g.cs | 24 ++ .../PatternSyntaxWrapper.g.cs | 24 ++ .../PositionalPatternClauseSyntaxWrapper.g.cs | 24 ++ ...imaryConstructorBaseTypeSyntaxWrapper.g.cs | 24 ++ .../PropertyPatternClauseSyntaxWrapper.g.cs | 24 ++ .../RangeExpressionSyntaxWrapper.g.cs | 24 ++ .../RecordDeclarationSyntaxWrapper.g.cs | 24 ++ .../RecursivePatternSyntaxWrapper.g.cs | 24 ++ .../RefExpressionSyntaxWrapper.g.cs | 24 ++ .../RefTypeSyntaxWrapper.g.cs | 24 ++ .../RelationalPatternSyntaxWrapper.g.cs | 24 ++ ...ingleVariableDesignationSyntaxWrapper.g.cs | 24 ++ .../SubpatternSyntaxWrapper.g.cs | 24 ++ .../SwitchExpressionArmSyntaxWrapper.g.cs | 24 ++ .../SwitchExpressionSyntaxWrapper.g.cs | 24 ++ .../ThrowExpressionSyntaxWrapper.g.cs | 24 ++ .../TupleElementSyntaxWrapper.g.cs | 24 ++ .../TupleExpressionSyntaxWrapper.g.cs | 24 ++ .../TupleTypeSyntaxWrapper.g.cs | 24 ++ .../TypePatternSyntaxWrapper.g.cs | 24 ++ .../UnaryPatternSyntaxWrapper.g.cs | 24 ++ .../VarPatternSyntaxWrapper.g.cs | 24 ++ .../VariableDesignationSyntaxWrapper.g.cs | 24 ++ .../WhenClauseSyntaxWrapper.g.cs | 24 ++ .../WithExpressionSyntaxWrapper.g.cs | 24 ++ .../CasePatternSwitchLabelSyntaxWrapper.cs | 14 +- .../CommonForEachStatementSyntaxWrapper.cs | 13 +- .../Lightup/ConstantPatternSyntaxWrapper.cs | 14 +- .../DeclarationExpressionSyntaxWrapper.cs | 14 +- .../DeclarationPatternSyntaxWrapper.cs | 14 +- .../DiscardDesignationSyntaxWrapper.cs | 14 +- .../Lightup/DiscardPatternSyntaxWrapper.cs | 14 +- .../ForEachVariableStatementSyntaxWrapper.cs | 14 +- ...locArrayCreationExpressionSyntaxWrapper.cs | 14 +- .../IsPatternExpressionSyntaxWrapper.cs | 14 +- .../LocalFunctionStatementSyntaxWrapper.cs | 14 +- ...hesizedVariableDesignationSyntaxWrapper.cs | 14 +- .../Lightup/PatternSyntaxWrapper.cs | 14 +- .../PositionalPatternClauseSyntaxWrapper.cs | 14 +- .../PropertyPatternClauseSyntaxWrapper.cs | 14 +- .../Lightup/RangeExpressionSyntaxWrapper.cs | 14 +- .../Lightup/RecursivePatternSyntaxWrapper.cs | 14 +- .../Lightup/RefExpressionSyntaxWrapper.cs | 14 +- .../Lightup/RefTypeSyntaxWrapper.cs | 14 +- .../SingleVariableDesignationSyntaxWrapper.cs | 14 +- .../Lightup/SubpatternSyntaxWrapper.cs | 14 +- .../SwitchExpressionArmSyntaxWrapper.cs | 14 +- .../Lightup/SwitchExpressionSyntaxWrapper.cs | 14 +- .../Lightup/ThrowExpressionSyntaxWrapper.cs | 14 +- .../Lightup/TupleElementSyntaxWrapper.cs | 14 +- .../Lightup/TupleExpressionSyntaxWrapper.cs | 14 +- .../Lightup/TupleTypeSyntaxWrapper.cs | 14 +- .../Lightup/VarPatternSyntaxWrapper.cs | 14 +- .../VariableDesignationSyntaxWrapper.cs | 14 +- .../Lightup/WhenClauseSyntaxWrapper.cs | 14 +- 82 files changed, 1492 insertions(+), 389 deletions(-) create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseObjectCreationExpressionSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseParameterSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BinaryPatternSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CasePatternSwitchLabelSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CommonForEachStatementSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ConstantPatternSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationExpressionSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationPatternSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DefaultConstraintSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardDesignationSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardPatternSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ExpressionOrPatternSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ForEachVariableStatementSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerCallingConventionSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterListSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerTypeSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionListSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitObjectCreationExpressionSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/IsPatternExpressionSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/LocalFunctionStatementSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/NullableDirectiveTriviaSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedPatternSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedVariableDesignationSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PatternSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PositionalPatternClauseSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PrimaryConstructorBaseTypeSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PropertyPatternClauseSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RangeExpressionSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecordDeclarationSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecursivePatternSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefExpressionSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefTypeSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RelationalPatternSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SingleVariableDesignationSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SubpatternSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionArmSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ThrowExpressionSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleElementSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleExpressionSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleTypeSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TypePatternSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/UnaryPatternSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VarPatternSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VariableDesignationSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WhenClauseSyntaxWrapper.g.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WithExpressionSyntaxWrapper.g.cs diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs b/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs new file mode 100644 index 0000000000..70b6ab5126 --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs @@ -0,0 +1,261 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.CodeGeneration +{ + using System; + using System.Collections.Generic; + using System.Collections.Immutable; + using System.IO; + using System.Linq; + using System.Text; + using System.Xml.Linq; + using System.Xml.XPath; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + using Microsoft.CodeAnalysis.Text; + + [Generator] + internal sealed class SyntaxLightupGenerator : ISourceGenerator + { + private enum NodeKind + { + Predefined, + Abstract, + Concrete, + } + + public void Initialize(GeneratorInitializationContext context) + { + } + + public void Execute(GeneratorExecutionContext context) + { + var syntaxFile = context.AdditionalFiles.Single(x => Path.GetFileName(x.Path) == "Syntax.xml"); + var syntaxText = syntaxFile.GetText(context.CancellationToken); + if (syntaxText is null) + { + throw new InvalidOperationException("Failed to read Syntax.xml"); + } + + var syntaxData = new SyntaxData(in context, XDocument.Parse(syntaxText.ToString())); + this.GenerateSyntaxWrappers(in context, syntaxData); + } + + private void GenerateSyntaxWrappers(in GeneratorExecutionContext context, SyntaxData syntaxData) + { + foreach (var node in syntaxData.Nodes) + { + if (node.WrapperName is not null) + { + this.GenerateSyntaxWrapper(in context, syntaxData, node); + } + } + } + + private void GenerateSyntaxWrapper(in GeneratorExecutionContext context, SyntaxData syntaxData, NodeData nodeData) + { + var concreteBase = syntaxData.TryGetConcreteBase(nodeData)?.Name ?? nameof(SyntaxNode); + + var members = SyntaxFactory.List(); + + // internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax"; + members = members.Add(SyntaxFactory.FieldDeclaration( + attributeLists: default, + modifiers: SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.InternalKeyword), SyntaxFactory.Token(SyntaxKind.ConstKeyword)), + declaration: SyntaxFactory.VariableDeclaration( + type: SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.StringKeyword)), + variables: SyntaxFactory.SingletonSeparatedList(SyntaxFactory.VariableDeclarator( + identifier: SyntaxFactory.Identifier("WrappedTypeName"), + argumentList: null, + initializer: SyntaxFactory.EqualsValueClause(SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal("Microsoft.CodeAnalysis.CSharp.Syntax." + nodeData.Name)))))))); + + // private static readonly Type WrappedType; + members = members.Add(SyntaxFactory.FieldDeclaration( + attributeLists: default, + modifiers: SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PrivateKeyword), SyntaxFactory.Token(SyntaxKind.StaticKeyword), SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword)), + declaration: SyntaxFactory.VariableDeclaration( + type: SyntaxFactory.IdentifierName("Type"), + variables: SyntaxFactory.SingletonSeparatedList(SyntaxFactory.VariableDeclarator("WrappedType"))))); + + // private readonly SyntaxNode node; + members = members.Add(SyntaxFactory.FieldDeclaration( + attributeLists: default, + modifiers: SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PrivateKeyword), SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword)), + declaration: SyntaxFactory.VariableDeclaration( + type: SyntaxFactory.IdentifierName(concreteBase), + variables: SyntaxFactory.SingletonSeparatedList(SyntaxFactory.VariableDeclarator("node"))))); + + // private SyntaxNodeWrapper(SyntaxNode node) + // { + // this.node = node; + // } + members = members.Add(SyntaxFactory.ConstructorDeclaration( + attributeLists: default, + modifiers: SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PrivateKeyword)), + identifier: SyntaxFactory.Identifier(nodeData.WrapperName), + parameterList: SyntaxFactory.ParameterList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Parameter( + attributeLists: default, + modifiers: default, + type: SyntaxFactory.IdentifierName(concreteBase), + identifier: SyntaxFactory.Identifier("node"), + @default: null))), + initializer: null, + body: SyntaxFactory.Block( + SyntaxFactory.ExpressionStatement(SyntaxFactory.AssignmentExpression( + SyntaxKind.SimpleAssignmentExpression, + left: SyntaxFactory.MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + expression: SyntaxFactory.ThisExpression(), + name: SyntaxFactory.IdentifierName("node")), + right: SyntaxFactory.IdentifierName("node")))))); + + // public SyntaxNode SyntaxNode => this.node; + members = members.Add(SyntaxFactory.PropertyDeclaration( + attributeLists: default, + modifiers: SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword)), + type: SyntaxFactory.IdentifierName(concreteBase), + explicitInterfaceSpecifier: null, + identifier: SyntaxFactory.Identifier("SyntaxNode"), + accessorList: null, + expressionBody: SyntaxFactory.ArrowExpressionClause(SyntaxFactory.MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + expression: SyntaxFactory.ThisExpression(), + name: SyntaxFactory.IdentifierName("node"))), + initializer: null, + semicolonToken: SyntaxFactory.Token(SyntaxKind.SemicolonToken))); + + var wrapperStruct = SyntaxFactory.StructDeclaration( + attributeLists: default, + modifiers: SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.InternalKeyword), SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword), SyntaxFactory.Token(SyntaxKind.PartialKeyword)), + identifier: SyntaxFactory.Identifier(nodeData.WrapperName), + typeParameterList: null, + baseList: SyntaxFactory.BaseList(SyntaxFactory.SingletonSeparatedList( + SyntaxFactory.SimpleBaseType(SyntaxFactory.GenericName( + identifier: SyntaxFactory.Identifier("ISyntaxWrapper"), + typeArgumentList: SyntaxFactory.TypeArgumentList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.IdentifierName(concreteBase))))))), + constraintClauses: default, + members: members); + var wrapperNamespace = SyntaxFactory.NamespaceDeclaration( + name: SyntaxFactory.ParseName("StyleCop.Analyzers.Lightup"), + externs: default, + usings: SyntaxFactory.List() + .Add(SyntaxFactory.UsingDirective(SyntaxFactory.ParseName("System"))) + .Add(SyntaxFactory.UsingDirective(SyntaxFactory.ParseName("System.Collections.Immutable"))) + .Add(SyntaxFactory.UsingDirective(SyntaxFactory.ParseName("Microsoft.CodeAnalysis"))) + .Add(SyntaxFactory.UsingDirective(SyntaxFactory.ParseName("Microsoft.CodeAnalysis.CSharp"))) + .Add(SyntaxFactory.UsingDirective(SyntaxFactory.ParseName("Microsoft.CodeAnalysis.CSharp.Syntax"))), + members: SyntaxFactory.SingletonList(wrapperStruct)); + + wrapperNamespace = wrapperNamespace + .NormalizeWhitespace() + .WithLeadingTrivia( + SyntaxFactory.Comment("// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved."), + SyntaxFactory.CarriageReturnLineFeed, + SyntaxFactory.Comment("// Licensed under the MIT License. See LICENSE in the project root for license information."), + SyntaxFactory.CarriageReturnLineFeed, + SyntaxFactory.CarriageReturnLineFeed) + .WithTrailingTrivia( + SyntaxFactory.CarriageReturnLineFeed); + + context.AddSource(nodeData.WrapperName + ".g.cs", SourceText.From(wrapperNamespace.ToFullString(), Encoding.UTF8)); + } + + private sealed class SyntaxData + { + private readonly Dictionary nameToNode; + + public SyntaxData(in GeneratorExecutionContext context, XDocument document) + { + var nodesBuilder = ImmutableArray.CreateBuilder(); + foreach (var element in document.XPathSelectElement("/Tree[@Root='SyntaxNode']").XPathSelectElements("PredefinedNode|AbstractNode|Node")) + { + nodesBuilder.Add(new NodeData(in context, element)); + } + + this.Nodes = nodesBuilder.ToImmutable(); + this.nameToNode = this.Nodes.ToDictionary(node => node.Name); + } + + public ImmutableArray Nodes { get; } + + public NodeData TryGetConcreteBase(NodeData node) + { + for (var current = this.TryGetNode(node.BaseName); current is not null; current = this.TryGetNode(current.BaseName)) + { + if (current.WrapperName is null) + { + // This is not a wrapper + return current; + } + } + + return null; + } + + private NodeData TryGetNode(string name) + { + this.nameToNode.TryGetValue(name, out var node); + return node; + } + } + + private sealed class NodeData + { + public NodeData(in GeneratorExecutionContext context, XElement element) + { + this.Kind = element.Name.LocalName switch + { + "PredefinedNode" => NodeKind.Predefined, + "AbstractNode" => NodeKind.Abstract, + "Node" => NodeKind.Concrete, + _ => throw new NotSupportedException($"Unknown element name '{element.Name}'"), + }; + + this.Name = element.Attribute("Name").Value; + + var existingType = context.Compilation.GetTypeByMetadataName($"Microsoft.CodeAnalysis.CSharp.Syntax.{this.Name}") + ?? context.Compilation.GetTypeByMetadataName($"Microsoft.CodeAnalysis.CSharp.{this.Name}") + ?? context.Compilation.GetTypeByMetadataName($"Microsoft.CodeAnalysis.{this.Name}"); + if (existingType?.DeclaredAccessibility == Accessibility.Public) + { + this.WrapperName = null; + } + else + { + this.WrapperName = this.Name + "Wrapper"; + } + + this.BaseName = element.Attribute("Base").Value; + this.Fields = element.XPathSelectElements("Field").Select(field => new FieldData(field)).ToImmutableArray(); + } + + public NodeKind Kind { get; } + + public string Name { get; } + + public string WrapperName { get; } + + public string BaseName { get; } + + public ImmutableArray Fields { get; } + } + + private sealed class FieldData + { + public FieldData(XElement element) + { + this.Name = element.Attribute("Name").Value; + this.Type = element.Attribute("Type").Value; + this.IsOverride = element.Attribute("Override")?.Value == "true"; + } + + public string Name { get; } + + public string Type { get; } + + public bool IsOverride { get; } + } + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.ruleset b/StyleCop.Analyzers/StyleCop.Analyzers.ruleset index d23c45b61a..35d99263d4 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers.ruleset +++ b/StyleCop.Analyzers/StyleCop.Analyzers.ruleset @@ -80,6 +80,7 @@ + diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseObjectCreationExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseObjectCreationExpressionSyntaxWrapper.g.cs new file mode 100644 index 0000000000..ac9e9668e0 --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseObjectCreationExpressionSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct BaseObjectCreationExpressionSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax"; + private static readonly Type WrappedType; + private readonly ExpressionSyntax node; + private BaseObjectCreationExpressionSyntaxWrapper(ExpressionSyntax node) + { + this.node = node; + } + + public ExpressionSyntax SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseParameterSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseParameterSyntaxWrapper.g.cs new file mode 100644 index 0000000000..46128ab2e4 --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseParameterSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct BaseParameterSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax"; + private static readonly Type WrappedType; + private readonly CSharpSyntaxNode node; + private BaseParameterSyntaxWrapper(CSharpSyntaxNode node) + { + this.node = node; + } + + public CSharpSyntaxNode SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BinaryPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BinaryPatternSyntaxWrapper.g.cs new file mode 100644 index 0000000000..a59a2bd188 --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BinaryPatternSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct BinaryPatternSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax"; + private static readonly Type WrappedType; + private readonly CSharpSyntaxNode node; + private BinaryPatternSyntaxWrapper(CSharpSyntaxNode node) + { + this.node = node; + } + + public CSharpSyntaxNode SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CasePatternSwitchLabelSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CasePatternSwitchLabelSyntaxWrapper.g.cs new file mode 100644 index 0000000000..451a4e3778 --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CasePatternSwitchLabelSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct CasePatternSwitchLabelSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax"; + private static readonly Type WrappedType; + private readonly SwitchLabelSyntax node; + private CasePatternSwitchLabelSyntaxWrapper(SwitchLabelSyntax node) + { + this.node = node; + } + + public SwitchLabelSyntax SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CommonForEachStatementSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CommonForEachStatementSyntaxWrapper.g.cs new file mode 100644 index 0000000000..53409f8a32 --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CommonForEachStatementSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct CommonForEachStatementSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax"; + private static readonly Type WrappedType; + private readonly StatementSyntax node; + private CommonForEachStatementSyntaxWrapper(StatementSyntax node) + { + this.node = node; + } + + public StatementSyntax SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ConstantPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ConstantPatternSyntaxWrapper.g.cs new file mode 100644 index 0000000000..7837fa3536 --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ConstantPatternSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct ConstantPatternSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax"; + private static readonly Type WrappedType; + private readonly CSharpSyntaxNode node; + private ConstantPatternSyntaxWrapper(CSharpSyntaxNode node) + { + this.node = node; + } + + public CSharpSyntaxNode SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationExpressionSyntaxWrapper.g.cs new file mode 100644 index 0000000000..16c59c9eeb --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationExpressionSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct DeclarationExpressionSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax"; + private static readonly Type WrappedType; + private readonly ExpressionSyntax node; + private DeclarationExpressionSyntaxWrapper(ExpressionSyntax node) + { + this.node = node; + } + + public ExpressionSyntax SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationPatternSyntaxWrapper.g.cs new file mode 100644 index 0000000000..7ed68637f9 --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationPatternSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct DeclarationPatternSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax"; + private static readonly Type WrappedType; + private readonly CSharpSyntaxNode node; + private DeclarationPatternSyntaxWrapper(CSharpSyntaxNode node) + { + this.node = node; + } + + public CSharpSyntaxNode SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DefaultConstraintSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DefaultConstraintSyntaxWrapper.g.cs new file mode 100644 index 0000000000..75aa657259 --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DefaultConstraintSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct DefaultConstraintSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax"; + private static readonly Type WrappedType; + private readonly TypeParameterConstraintSyntax node; + private DefaultConstraintSyntaxWrapper(TypeParameterConstraintSyntax node) + { + this.node = node; + } + + public TypeParameterConstraintSyntax SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardDesignationSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardDesignationSyntaxWrapper.g.cs new file mode 100644 index 0000000000..0f63f2a912 --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardDesignationSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct DiscardDesignationSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax"; + private static readonly Type WrappedType; + private readonly CSharpSyntaxNode node; + private DiscardDesignationSyntaxWrapper(CSharpSyntaxNode node) + { + this.node = node; + } + + public CSharpSyntaxNode SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardPatternSyntaxWrapper.g.cs new file mode 100644 index 0000000000..38e8ac2b2e --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardPatternSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct DiscardPatternSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax"; + private static readonly Type WrappedType; + private readonly CSharpSyntaxNode node; + private DiscardPatternSyntaxWrapper(CSharpSyntaxNode node) + { + this.node = node; + } + + public CSharpSyntaxNode SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ExpressionOrPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ExpressionOrPatternSyntaxWrapper.g.cs new file mode 100644 index 0000000000..30c86eef2d --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ExpressionOrPatternSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct ExpressionOrPatternSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionOrPatternSyntax"; + private static readonly Type WrappedType; + private readonly CSharpSyntaxNode node; + private ExpressionOrPatternSyntaxWrapper(CSharpSyntaxNode node) + { + this.node = node; + } + + public CSharpSyntaxNode SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ForEachVariableStatementSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ForEachVariableStatementSyntaxWrapper.g.cs new file mode 100644 index 0000000000..91e74e7be8 --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ForEachVariableStatementSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct ForEachVariableStatementSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax"; + private static readonly Type WrappedType; + private readonly StatementSyntax node; + private ForEachVariableStatementSyntaxWrapper(StatementSyntax node) + { + this.node = node; + } + + public StatementSyntax SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerCallingConventionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerCallingConventionSyntaxWrapper.g.cs new file mode 100644 index 0000000000..132d498f01 --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerCallingConventionSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct FunctionPointerCallingConventionSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax"; + private static readonly Type WrappedType; + private readonly CSharpSyntaxNode node; + private FunctionPointerCallingConventionSyntaxWrapper(CSharpSyntaxNode node) + { + this.node = node; + } + + public CSharpSyntaxNode SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterListSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterListSyntaxWrapper.g.cs new file mode 100644 index 0000000000..647ec96dd0 --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterListSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct FunctionPointerParameterListSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax"; + private static readonly Type WrappedType; + private readonly CSharpSyntaxNode node; + private FunctionPointerParameterListSyntaxWrapper(CSharpSyntaxNode node) + { + this.node = node; + } + + public CSharpSyntaxNode SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterSyntaxWrapper.g.cs new file mode 100644 index 0000000000..a0952ecc7c --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct FunctionPointerParameterSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax"; + private static readonly Type WrappedType; + private readonly CSharpSyntaxNode node; + private FunctionPointerParameterSyntaxWrapper(CSharpSyntaxNode node) + { + this.node = node; + } + + public CSharpSyntaxNode SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerTypeSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerTypeSyntaxWrapper.g.cs new file mode 100644 index 0000000000..00c7f446a5 --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerTypeSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct FunctionPointerTypeSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax"; + private static readonly Type WrappedType; + private readonly TypeSyntax node; + private FunctionPointerTypeSyntaxWrapper(TypeSyntax node) + { + this.node = node; + } + + public TypeSyntax SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionListSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionListSyntaxWrapper.g.cs new file mode 100644 index 0000000000..f664754586 --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionListSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct FunctionPointerUnmanagedCallingConventionListSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax"; + private static readonly Type WrappedType; + private readonly CSharpSyntaxNode node; + private FunctionPointerUnmanagedCallingConventionListSyntaxWrapper(CSharpSyntaxNode node) + { + this.node = node; + } + + public CSharpSyntaxNode SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionSyntaxWrapper.g.cs new file mode 100644 index 0000000000..3046452ff6 --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct FunctionPointerUnmanagedCallingConventionSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax"; + private static readonly Type WrappedType; + private readonly CSharpSyntaxNode node; + private FunctionPointerUnmanagedCallingConventionSyntaxWrapper(CSharpSyntaxNode node) + { + this.node = node; + } + + public CSharpSyntaxNode SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitObjectCreationExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitObjectCreationExpressionSyntaxWrapper.g.cs new file mode 100644 index 0000000000..d2415e11c3 --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitObjectCreationExpressionSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct ImplicitObjectCreationExpressionSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax"; + private static readonly Type WrappedType; + private readonly ExpressionSyntax node; + private ImplicitObjectCreationExpressionSyntaxWrapper(ExpressionSyntax node) + { + this.node = node; + } + + public ExpressionSyntax SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.g.cs new file mode 100644 index 0000000000..eb3ef15a37 --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct ImplicitStackAllocArrayCreationExpressionSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax"; + private static readonly Type WrappedType; + private readonly ExpressionSyntax node; + private ImplicitStackAllocArrayCreationExpressionSyntaxWrapper(ExpressionSyntax node) + { + this.node = node; + } + + public ExpressionSyntax SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/IsPatternExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/IsPatternExpressionSyntaxWrapper.g.cs new file mode 100644 index 0000000000..94df227002 --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/IsPatternExpressionSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct IsPatternExpressionSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax"; + private static readonly Type WrappedType; + private readonly ExpressionSyntax node; + private IsPatternExpressionSyntaxWrapper(ExpressionSyntax node) + { + this.node = node; + } + + public ExpressionSyntax SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/LocalFunctionStatementSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/LocalFunctionStatementSyntaxWrapper.g.cs new file mode 100644 index 0000000000..ca394dabdf --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/LocalFunctionStatementSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct LocalFunctionStatementSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax"; + private static readonly Type WrappedType; + private readonly StatementSyntax node; + private LocalFunctionStatementSyntaxWrapper(StatementSyntax node) + { + this.node = node; + } + + public StatementSyntax SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/NullableDirectiveTriviaSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/NullableDirectiveTriviaSyntaxWrapper.g.cs new file mode 100644 index 0000000000..f09864156b --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/NullableDirectiveTriviaSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct NullableDirectiveTriviaSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax"; + private static readonly Type WrappedType; + private readonly DirectiveTriviaSyntax node; + private NullableDirectiveTriviaSyntaxWrapper(DirectiveTriviaSyntax node) + { + this.node = node; + } + + public DirectiveTriviaSyntax SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedPatternSyntaxWrapper.g.cs new file mode 100644 index 0000000000..cf8227cee6 --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedPatternSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct ParenthesizedPatternSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax"; + private static readonly Type WrappedType; + private readonly CSharpSyntaxNode node; + private ParenthesizedPatternSyntaxWrapper(CSharpSyntaxNode node) + { + this.node = node; + } + + public CSharpSyntaxNode SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedVariableDesignationSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedVariableDesignationSyntaxWrapper.g.cs new file mode 100644 index 0000000000..a3653d134f --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedVariableDesignationSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct ParenthesizedVariableDesignationSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax"; + private static readonly Type WrappedType; + private readonly CSharpSyntaxNode node; + private ParenthesizedVariableDesignationSyntaxWrapper(CSharpSyntaxNode node) + { + this.node = node; + } + + public CSharpSyntaxNode SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PatternSyntaxWrapper.g.cs new file mode 100644 index 0000000000..553db7d951 --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PatternSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct PatternSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax"; + private static readonly Type WrappedType; + private readonly CSharpSyntaxNode node; + private PatternSyntaxWrapper(CSharpSyntaxNode node) + { + this.node = node; + } + + public CSharpSyntaxNode SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PositionalPatternClauseSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PositionalPatternClauseSyntaxWrapper.g.cs new file mode 100644 index 0000000000..8abba461b6 --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PositionalPatternClauseSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct PositionalPatternClauseSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax"; + private static readonly Type WrappedType; + private readonly CSharpSyntaxNode node; + private PositionalPatternClauseSyntaxWrapper(CSharpSyntaxNode node) + { + this.node = node; + } + + public CSharpSyntaxNode SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PrimaryConstructorBaseTypeSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PrimaryConstructorBaseTypeSyntaxWrapper.g.cs new file mode 100644 index 0000000000..a9488848e0 --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PrimaryConstructorBaseTypeSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct PrimaryConstructorBaseTypeSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax"; + private static readonly Type WrappedType; + private readonly BaseTypeSyntax node; + private PrimaryConstructorBaseTypeSyntaxWrapper(BaseTypeSyntax node) + { + this.node = node; + } + + public BaseTypeSyntax SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PropertyPatternClauseSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PropertyPatternClauseSyntaxWrapper.g.cs new file mode 100644 index 0000000000..128e3b97af --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PropertyPatternClauseSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct PropertyPatternClauseSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax"; + private static readonly Type WrappedType; + private readonly CSharpSyntaxNode node; + private PropertyPatternClauseSyntaxWrapper(CSharpSyntaxNode node) + { + this.node = node; + } + + public CSharpSyntaxNode SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RangeExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RangeExpressionSyntaxWrapper.g.cs new file mode 100644 index 0000000000..66cfa92f6d --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RangeExpressionSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct RangeExpressionSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax"; + private static readonly Type WrappedType; + private readonly ExpressionSyntax node; + private RangeExpressionSyntaxWrapper(ExpressionSyntax node) + { + this.node = node; + } + + public ExpressionSyntax SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecordDeclarationSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecordDeclarationSyntaxWrapper.g.cs new file mode 100644 index 0000000000..27ee28139c --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecordDeclarationSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct RecordDeclarationSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax"; + private static readonly Type WrappedType; + private readonly TypeDeclarationSyntax node; + private RecordDeclarationSyntaxWrapper(TypeDeclarationSyntax node) + { + this.node = node; + } + + public TypeDeclarationSyntax SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecursivePatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecursivePatternSyntaxWrapper.g.cs new file mode 100644 index 0000000000..9da6da793e --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecursivePatternSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct RecursivePatternSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax"; + private static readonly Type WrappedType; + private readonly CSharpSyntaxNode node; + private RecursivePatternSyntaxWrapper(CSharpSyntaxNode node) + { + this.node = node; + } + + public CSharpSyntaxNode SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefExpressionSyntaxWrapper.g.cs new file mode 100644 index 0000000000..486612e4bf --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefExpressionSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct RefExpressionSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax"; + private static readonly Type WrappedType; + private readonly ExpressionSyntax node; + private RefExpressionSyntaxWrapper(ExpressionSyntax node) + { + this.node = node; + } + + public ExpressionSyntax SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefTypeSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefTypeSyntaxWrapper.g.cs new file mode 100644 index 0000000000..a944410eb8 --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefTypeSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct RefTypeSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax"; + private static readonly Type WrappedType; + private readonly TypeSyntax node; + private RefTypeSyntaxWrapper(TypeSyntax node) + { + this.node = node; + } + + public TypeSyntax SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RelationalPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RelationalPatternSyntaxWrapper.g.cs new file mode 100644 index 0000000000..9d0ac681c7 --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RelationalPatternSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct RelationalPatternSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax"; + private static readonly Type WrappedType; + private readonly CSharpSyntaxNode node; + private RelationalPatternSyntaxWrapper(CSharpSyntaxNode node) + { + this.node = node; + } + + public CSharpSyntaxNode SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SingleVariableDesignationSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SingleVariableDesignationSyntaxWrapper.g.cs new file mode 100644 index 0000000000..d8993920f1 --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SingleVariableDesignationSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct SingleVariableDesignationSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax"; + private static readonly Type WrappedType; + private readonly CSharpSyntaxNode node; + private SingleVariableDesignationSyntaxWrapper(CSharpSyntaxNode node) + { + this.node = node; + } + + public CSharpSyntaxNode SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SubpatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SubpatternSyntaxWrapper.g.cs new file mode 100644 index 0000000000..49a19ac628 --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SubpatternSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct SubpatternSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax"; + private static readonly Type WrappedType; + private readonly CSharpSyntaxNode node; + private SubpatternSyntaxWrapper(CSharpSyntaxNode node) + { + this.node = node; + } + + public CSharpSyntaxNode SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionArmSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionArmSyntaxWrapper.g.cs new file mode 100644 index 0000000000..09583e9221 --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionArmSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct SwitchExpressionArmSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax"; + private static readonly Type WrappedType; + private readonly CSharpSyntaxNode node; + private SwitchExpressionArmSyntaxWrapper(CSharpSyntaxNode node) + { + this.node = node; + } + + public CSharpSyntaxNode SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionSyntaxWrapper.g.cs new file mode 100644 index 0000000000..41e8e4fbbe --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct SwitchExpressionSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax"; + private static readonly Type WrappedType; + private readonly ExpressionSyntax node; + private SwitchExpressionSyntaxWrapper(ExpressionSyntax node) + { + this.node = node; + } + + public ExpressionSyntax SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ThrowExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ThrowExpressionSyntaxWrapper.g.cs new file mode 100644 index 0000000000..5b433b633b --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ThrowExpressionSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct ThrowExpressionSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax"; + private static readonly Type WrappedType; + private readonly ExpressionSyntax node; + private ThrowExpressionSyntaxWrapper(ExpressionSyntax node) + { + this.node = node; + } + + public ExpressionSyntax SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleElementSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleElementSyntaxWrapper.g.cs new file mode 100644 index 0000000000..613100c075 --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleElementSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct TupleElementSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax"; + private static readonly Type WrappedType; + private readonly CSharpSyntaxNode node; + private TupleElementSyntaxWrapper(CSharpSyntaxNode node) + { + this.node = node; + } + + public CSharpSyntaxNode SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleExpressionSyntaxWrapper.g.cs new file mode 100644 index 0000000000..398fffd99b --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleExpressionSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct TupleExpressionSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax"; + private static readonly Type WrappedType; + private readonly ExpressionSyntax node; + private TupleExpressionSyntaxWrapper(ExpressionSyntax node) + { + this.node = node; + } + + public ExpressionSyntax SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleTypeSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleTypeSyntaxWrapper.g.cs new file mode 100644 index 0000000000..aa9e2127a8 --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleTypeSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct TupleTypeSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax"; + private static readonly Type WrappedType; + private readonly TypeSyntax node; + private TupleTypeSyntaxWrapper(TypeSyntax node) + { + this.node = node; + } + + public TypeSyntax SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TypePatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TypePatternSyntaxWrapper.g.cs new file mode 100644 index 0000000000..5f4911584c --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TypePatternSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct TypePatternSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax"; + private static readonly Type WrappedType; + private readonly CSharpSyntaxNode node; + private TypePatternSyntaxWrapper(CSharpSyntaxNode node) + { + this.node = node; + } + + public CSharpSyntaxNode SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/UnaryPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/UnaryPatternSyntaxWrapper.g.cs new file mode 100644 index 0000000000..3921620dc9 --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/UnaryPatternSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct UnaryPatternSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax"; + private static readonly Type WrappedType; + private readonly CSharpSyntaxNode node; + private UnaryPatternSyntaxWrapper(CSharpSyntaxNode node) + { + this.node = node; + } + + public CSharpSyntaxNode SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VarPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VarPatternSyntaxWrapper.g.cs new file mode 100644 index 0000000000..1cefbaa0b1 --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VarPatternSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct VarPatternSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax"; + private static readonly Type WrappedType; + private readonly CSharpSyntaxNode node; + private VarPatternSyntaxWrapper(CSharpSyntaxNode node) + { + this.node = node; + } + + public CSharpSyntaxNode SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VariableDesignationSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VariableDesignationSyntaxWrapper.g.cs new file mode 100644 index 0000000000..4b1836b860 --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VariableDesignationSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct VariableDesignationSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax"; + private static readonly Type WrappedType; + private readonly CSharpSyntaxNode node; + private VariableDesignationSyntaxWrapper(CSharpSyntaxNode node) + { + this.node = node; + } + + public CSharpSyntaxNode SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WhenClauseSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WhenClauseSyntaxWrapper.g.cs new file mode 100644 index 0000000000..73047e8d13 --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WhenClauseSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct WhenClauseSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax"; + private static readonly Type WrappedType; + private readonly CSharpSyntaxNode node; + private WhenClauseSyntaxWrapper(CSharpSyntaxNode node) + { + this.node = node; + } + + public CSharpSyntaxNode SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WithExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WithExpressionSyntaxWrapper.g.cs new file mode 100644 index 0000000000..40ba2f7134 --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WithExpressionSyntaxWrapper.g.cs @@ -0,0 +1,24 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using System.Collections.Immutable; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal readonly partial struct WithExpressionSyntaxWrapper : ISyntaxWrapper + { + internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax"; + private static readonly Type WrappedType; + private readonly ExpressionSyntax node; + private WithExpressionSyntaxWrapper(ExpressionSyntax node) + { + this.node = node; + } + + public ExpressionSyntax SyntaxNode => this.node; + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CasePatternSwitchLabelSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CasePatternSwitchLabelSyntaxWrapper.cs index 85ab741d58..718cd16c2d 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CasePatternSwitchLabelSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CasePatternSwitchLabelSyntaxWrapper.cs @@ -8,11 +8,8 @@ namespace StyleCop.Analyzers.Lightup using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.CSharp.Syntax; - internal struct CasePatternSwitchLabelSyntaxWrapper : ISyntaxWrapper + internal partial struct CasePatternSwitchLabelSyntaxWrapper : ISyntaxWrapper { - internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax"; - private static readonly Type WrappedType; - private static readonly Func PatternAccessor; private static readonly Func WhenClauseAccessor; private static readonly Func WithKeywordAccessor; @@ -20,8 +17,6 @@ internal struct CasePatternSwitchLabelSyntaxWrapper : ISyntaxWrapper WithPatternAccessor; private static readonly Func WithWhenClauseAccessor; - private readonly SwitchLabelSyntax node; - static CasePatternSwitchLabelSyntaxWrapper() { WrappedType = WrapperHelper.GetWrappedType(typeof(CasePatternSwitchLabelSyntaxWrapper)); @@ -33,13 +28,6 @@ static CasePatternSwitchLabelSyntaxWrapper() WithWhenClauseAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(WhenClause)); } - private CasePatternSwitchLabelSyntaxWrapper(SwitchLabelSyntax node) - { - this.node = node; - } - - public SwitchLabelSyntax SyntaxNode => this.node; - public PatternSyntaxWrapper Pattern { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CommonForEachStatementSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CommonForEachStatementSyntaxWrapper.cs index b7ccd1f6b8..edf3f12c0d 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CommonForEachStatementSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CommonForEachStatementSyntaxWrapper.cs @@ -7,11 +7,9 @@ namespace StyleCop.Analyzers.Lightup using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp.Syntax; - internal struct CommonForEachStatementSyntaxWrapper : ISyntaxWrapper + internal partial struct CommonForEachStatementSyntaxWrapper : ISyntaxWrapper { - internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax"; internal const string FallbackWrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.ForEachStatementSyntax"; - private static readonly Type WrappedType; private static readonly Func AwaitKeywordAccessor; private static readonly Func ForEachKeywordAccessor; @@ -29,8 +27,6 @@ internal struct CommonForEachStatementSyntaxWrapper : ISyntaxWrapper WithCloseParenTokenAccessor; private static readonly Func WithStatementAccessor; - private readonly StatementSyntax node; - static CommonForEachStatementSyntaxWrapper() { WrappedType = WrapperHelper.GetWrappedType(typeof(CommonForEachStatementSyntaxWrapper)); @@ -51,13 +47,6 @@ static CommonForEachStatementSyntaxWrapper() WithStatementAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Statement)); } - private CommonForEachStatementSyntaxWrapper(StatementSyntax node) - { - this.node = node; - } - - public StatementSyntax SyntaxNode => this.node; - public SyntaxToken AwaitKeyword { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ConstantPatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ConstantPatternSyntaxWrapper.cs index 016223938b..b558af1dc2 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ConstantPatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ConstantPatternSyntaxWrapper.cs @@ -8,16 +8,11 @@ namespace StyleCop.Analyzers.Lightup using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.CSharp.Syntax; - internal struct ConstantPatternSyntaxWrapper : ISyntaxWrapper + internal partial struct ConstantPatternSyntaxWrapper : ISyntaxWrapper { - internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax"; - private static readonly Type WrappedType; - private static readonly Func ExpressionAccessor; private static readonly Func WithExpressionAccessor; - private readonly CSharpSyntaxNode node; - static ConstantPatternSyntaxWrapper() { WrappedType = WrapperHelper.GetWrappedType(typeof(ConstantPatternSyntaxWrapper)); @@ -25,13 +20,6 @@ static ConstantPatternSyntaxWrapper() WithExpressionAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Expression)); } - private ConstantPatternSyntaxWrapper(CSharpSyntaxNode node) - { - this.node = node; - } - - public CSharpSyntaxNode SyntaxNode => this.node; - public ExpressionSyntax Expression { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationExpressionSyntaxWrapper.cs index 5e5dc7ebbd..3c620bfae9 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationExpressionSyntaxWrapper.cs @@ -8,18 +8,13 @@ namespace StyleCop.Analyzers.Lightup using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.CSharp.Syntax; - internal struct DeclarationExpressionSyntaxWrapper : ISyntaxWrapper + internal partial struct DeclarationExpressionSyntaxWrapper : ISyntaxWrapper { - internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax"; - private static readonly Type WrappedType; - private static readonly Func TypeAccessor; private static readonly Func DesignationAccessor; private static readonly Func WithTypeAccessor; private static readonly Func WithDesignationAccessor; - private readonly ExpressionSyntax node; - static DeclarationExpressionSyntaxWrapper() { WrappedType = WrapperHelper.GetWrappedType(typeof(DeclarationExpressionSyntaxWrapper)); @@ -29,13 +24,6 @@ static DeclarationExpressionSyntaxWrapper() WithDesignationAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Designation)); } - private DeclarationExpressionSyntaxWrapper(ExpressionSyntax node) - { - this.node = node; - } - - public ExpressionSyntax SyntaxNode => this.node; - public TypeSyntax Type { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationPatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationPatternSyntaxWrapper.cs index 0d4a76ff93..04232eb19f 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationPatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationPatternSyntaxWrapper.cs @@ -8,18 +8,13 @@ namespace StyleCop.Analyzers.Lightup using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.CSharp.Syntax; - internal struct DeclarationPatternSyntaxWrapper : ISyntaxWrapper + internal partial struct DeclarationPatternSyntaxWrapper : ISyntaxWrapper { - internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax"; - private static readonly Type WrappedType; - private static readonly Func TypeAccessor; private static readonly Func DesignationAccessor; private static readonly Func WithTypeAccessor; private static readonly Func WithDesignationAccessor; - private readonly CSharpSyntaxNode node; - static DeclarationPatternSyntaxWrapper() { WrappedType = WrapperHelper.GetWrappedType(typeof(DeclarationPatternSyntaxWrapper)); @@ -29,13 +24,6 @@ static DeclarationPatternSyntaxWrapper() WithDesignationAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Designation)); } - private DeclarationPatternSyntaxWrapper(CSharpSyntaxNode node) - { - this.node = node; - } - - public CSharpSyntaxNode SyntaxNode => this.node; - public TypeSyntax Type { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardDesignationSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardDesignationSyntaxWrapper.cs index 5b892aa2e4..f257882c13 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardDesignationSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardDesignationSyntaxWrapper.cs @@ -7,16 +7,11 @@ namespace StyleCop.Analyzers.Lightup using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; - internal struct DiscardDesignationSyntaxWrapper : ISyntaxWrapper + internal partial struct DiscardDesignationSyntaxWrapper : ISyntaxWrapper { - internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax"; - private static readonly Type WrappedType; - private static readonly Func UnderscoreTokenAccessor; private static readonly Func WithUnderscoreTokenAccessor; - private readonly CSharpSyntaxNode node; - static DiscardDesignationSyntaxWrapper() { WrappedType = WrapperHelper.GetWrappedType(typeof(DiscardDesignationSyntaxWrapper)); @@ -24,13 +19,6 @@ static DiscardDesignationSyntaxWrapper() WithUnderscoreTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(UnderscoreToken)); } - private DiscardDesignationSyntaxWrapper(CSharpSyntaxNode node) - { - this.node = node; - } - - public CSharpSyntaxNode SyntaxNode => this.node; - public SyntaxToken UnderscoreToken { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardPatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardPatternSyntaxWrapper.cs index c05388c5e3..f59a3f390f 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardPatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardPatternSyntaxWrapper.cs @@ -7,16 +7,11 @@ namespace StyleCop.Analyzers.Lightup using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; - internal struct DiscardPatternSyntaxWrapper : ISyntaxWrapper + internal partial struct DiscardPatternSyntaxWrapper : ISyntaxWrapper { - internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax"; - private static readonly Type WrappedType; - private static readonly Func UnderscoreTokenAccessor; private static readonly Func WithUnderscoreTokenAccessor; - private readonly CSharpSyntaxNode node; - static DiscardPatternSyntaxWrapper() { WrappedType = WrapperHelper.GetWrappedType(typeof(DiscardPatternSyntaxWrapper)); @@ -24,13 +19,6 @@ static DiscardPatternSyntaxWrapper() WithUnderscoreTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(UnderscoreToken)); } - private DiscardPatternSyntaxWrapper(CSharpSyntaxNode node) - { - this.node = node; - } - - public CSharpSyntaxNode SyntaxNode => this.node; - public SyntaxToken UnderscoreToken { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ForEachVariableStatementSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ForEachVariableStatementSyntaxWrapper.cs index 5a9b76af71..7f7ec15f9c 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ForEachVariableStatementSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ForEachVariableStatementSyntaxWrapper.cs @@ -7,11 +7,8 @@ namespace StyleCop.Analyzers.Lightup using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp.Syntax; - internal struct ForEachVariableStatementSyntaxWrapper : ISyntaxWrapper + internal partial struct ForEachVariableStatementSyntaxWrapper : ISyntaxWrapper { - internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax"; - private static readonly Type WrappedType; - private static readonly Func VariableAccessor; private static readonly Func WithAwaitKeywordAccessor; @@ -23,8 +20,6 @@ internal struct ForEachVariableStatementSyntaxWrapper : ISyntaxWrapper WithCloseParenTokenAccessor; private static readonly Func WithStatementAccessor; - private readonly StatementSyntax node; - static ForEachVariableStatementSyntaxWrapper() { WrappedType = WrapperHelper.GetWrappedType(typeof(ForEachVariableStatementSyntaxWrapper)); @@ -40,13 +35,6 @@ static ForEachVariableStatementSyntaxWrapper() WithStatementAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Statement)); } - private ForEachVariableStatementSyntaxWrapper(StatementSyntax node) - { - this.node = node; - } - - public StatementSyntax SyntaxNode => this.node; - public SyntaxToken AwaitKeyword { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.cs index 952809c559..b05e983ef1 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.cs @@ -7,11 +7,8 @@ namespace StyleCop.Analyzers.Lightup using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp.Syntax; - internal struct ImplicitStackAllocArrayCreationExpressionSyntaxWrapper : ISyntaxWrapper + internal partial struct ImplicitStackAllocArrayCreationExpressionSyntaxWrapper : ISyntaxWrapper { - internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax"; - private static readonly Type WrappedType; - private static readonly Func StackAllocKeywordAccessor; private static readonly Func OpenBracketTokenAccessor; private static readonly Func CloseBracketTokenAccessor; @@ -21,8 +18,6 @@ internal struct ImplicitStackAllocArrayCreationExpressionSyntaxWrapper : ISyntax private static readonly Func WithCloseBracketTokenAccessor; private static readonly Func WithInitializerAccessor; - private readonly ExpressionSyntax node; - static ImplicitStackAllocArrayCreationExpressionSyntaxWrapper() { WrappedType = WrapperHelper.GetWrappedType(typeof(ImplicitStackAllocArrayCreationExpressionSyntaxWrapper)); @@ -36,13 +31,6 @@ static ImplicitStackAllocArrayCreationExpressionSyntaxWrapper() WithInitializerAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Initializer)); } - private ImplicitStackAllocArrayCreationExpressionSyntaxWrapper(ExpressionSyntax node) - { - this.node = node; - } - - public ExpressionSyntax SyntaxNode => this.node; - public SyntaxToken StackAllocKeyword { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/IsPatternExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/IsPatternExpressionSyntaxWrapper.cs index 9012268d7e..736d70a50f 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/IsPatternExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/IsPatternExpressionSyntaxWrapper.cs @@ -8,11 +8,8 @@ namespace StyleCop.Analyzers.Lightup using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.CSharp.Syntax; - internal struct IsPatternExpressionSyntaxWrapper : ISyntaxWrapper + internal partial struct IsPatternExpressionSyntaxWrapper : ISyntaxWrapper { - internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax"; - private static readonly Type WrappedType; - private static readonly Func ExpressionAccessor; private static readonly Func IsKeywordAccessor; private static readonly Func PatternAccessor; @@ -20,8 +17,6 @@ internal struct IsPatternExpressionSyntaxWrapper : ISyntaxWrapper WithIsKeywordAccessor; private static readonly Func WithPatternAccessor; - private readonly ExpressionSyntax node; - static IsPatternExpressionSyntaxWrapper() { WrappedType = WrapperHelper.GetWrappedType(typeof(IsPatternExpressionSyntaxWrapper)); @@ -33,13 +28,6 @@ static IsPatternExpressionSyntaxWrapper() WithPatternAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Pattern)); } - private IsPatternExpressionSyntaxWrapper(ExpressionSyntax node) - { - this.node = node; - } - - public ExpressionSyntax SyntaxNode => this.node; - public ExpressionSyntax Expression { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/LocalFunctionStatementSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/LocalFunctionStatementSyntaxWrapper.cs index f431d185e8..4272db18a0 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/LocalFunctionStatementSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/LocalFunctionStatementSyntaxWrapper.cs @@ -8,11 +8,8 @@ namespace StyleCop.Analyzers.Lightup using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.CSharp.Syntax; - internal struct LocalFunctionStatementSyntaxWrapper : ISyntaxWrapper + internal partial struct LocalFunctionStatementSyntaxWrapper : ISyntaxWrapper { - internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax"; - private static readonly Type WrappedType; - private static readonly Func ModifiersAccessor; private static readonly Func ReturnTypeAccessor; private static readonly Func IdentifierAccessor; @@ -32,8 +29,6 @@ internal struct LocalFunctionStatementSyntaxWrapper : ISyntaxWrapper WithExpressionBodyAccessor; private static readonly Func WithSemicolonTokenAccessor; - private readonly StatementSyntax node; - static LocalFunctionStatementSyntaxWrapper() { WrappedType = WrapperHelper.GetWrappedType(typeof(LocalFunctionStatementSyntaxWrapper)); @@ -57,13 +52,6 @@ static LocalFunctionStatementSyntaxWrapper() WithSemicolonTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(SemicolonToken)); } - private LocalFunctionStatementSyntaxWrapper(StatementSyntax node) - { - this.node = node; - } - - public StatementSyntax SyntaxNode => this.node; - public SyntaxTokenList Modifiers { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ParenthesizedVariableDesignationSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ParenthesizedVariableDesignationSyntaxWrapper.cs index 0507883e83..2d46b9389f 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ParenthesizedVariableDesignationSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ParenthesizedVariableDesignationSyntaxWrapper.cs @@ -7,11 +7,8 @@ namespace StyleCop.Analyzers.Lightup using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; - internal struct ParenthesizedVariableDesignationSyntaxWrapper : ISyntaxWrapper + internal partial struct ParenthesizedVariableDesignationSyntaxWrapper : ISyntaxWrapper { - internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax"; - private static readonly Type WrappedType; - private static readonly Func OpenParenTokenAccessor; private static readonly Func> VariablesAccessor; private static readonly Func CloseParenTokenAccessor; @@ -19,8 +16,6 @@ internal struct ParenthesizedVariableDesignationSyntaxWrapper : ISyntaxWrapper, CSharpSyntaxNode> WithVariablesAccessor; private static readonly Func WithCloseParenTokenAccessor; - private readonly CSharpSyntaxNode node; - static ParenthesizedVariableDesignationSyntaxWrapper() { WrappedType = WrapperHelper.GetWrappedType(typeof(ParenthesizedVariableDesignationSyntaxWrapper)); @@ -32,13 +27,6 @@ static ParenthesizedVariableDesignationSyntaxWrapper() WithCloseParenTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(CloseParenToken)); } - private ParenthesizedVariableDesignationSyntaxWrapper(CSharpSyntaxNode node) - { - this.node = node; - } - - public CSharpSyntaxNode SyntaxNode => this.node; - public SyntaxToken OpenParenToken { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PatternSyntaxWrapper.cs index 48bb37822a..89b3186f8d 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PatternSyntaxWrapper.cs @@ -7,25 +7,13 @@ namespace StyleCop.Analyzers.Lightup using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; - internal struct PatternSyntaxWrapper : ISyntaxWrapper + internal partial struct PatternSyntaxWrapper : ISyntaxWrapper { - internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax"; - private static readonly Type WrappedType; - - private readonly CSharpSyntaxNode node; - static PatternSyntaxWrapper() { WrappedType = WrapperHelper.GetWrappedType(typeof(PatternSyntaxWrapper)); } - private PatternSyntaxWrapper(CSharpSyntaxNode node) - { - this.node = node; - } - - public CSharpSyntaxNode SyntaxNode => this.node; - public static explicit operator PatternSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PositionalPatternClauseSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PositionalPatternClauseSyntaxWrapper.cs index 5b715af41d..2bcf31f167 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PositionalPatternClauseSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PositionalPatternClauseSyntaxWrapper.cs @@ -7,11 +7,8 @@ namespace StyleCop.Analyzers.Lightup using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; - internal struct PositionalPatternClauseSyntaxWrapper : ISyntaxWrapper + internal partial struct PositionalPatternClauseSyntaxWrapper : ISyntaxWrapper { - internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax"; - private static readonly Type WrappedType; - private static readonly Func OpenParenTokenAccessor; private static readonly Func> SubpatternsAccessor; private static readonly Func CloseParenTokenAccessor; @@ -20,8 +17,6 @@ internal struct PositionalPatternClauseSyntaxWrapper : ISyntaxWrapper, CSharpSyntaxNode> WithSubpatternsAccessor; private static readonly Func WithCloseParenTokenAccessor; - private readonly CSharpSyntaxNode node; - static PositionalPatternClauseSyntaxWrapper() { WrappedType = WrapperHelper.GetWrappedType(typeof(PositionalPatternClauseSyntaxWrapper)); @@ -34,13 +29,6 @@ static PositionalPatternClauseSyntaxWrapper() WithCloseParenTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(CloseParenToken)); } - private PositionalPatternClauseSyntaxWrapper(CSharpSyntaxNode node) - { - this.node = node; - } - - public CSharpSyntaxNode SyntaxNode => this.node; - public SyntaxToken OpenParenToken { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PropertyPatternClauseSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PropertyPatternClauseSyntaxWrapper.cs index 00ed4c895a..dc058be1c8 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PropertyPatternClauseSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PropertyPatternClauseSyntaxWrapper.cs @@ -7,11 +7,8 @@ namespace StyleCop.Analyzers.Lightup using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; - internal struct PropertyPatternClauseSyntaxWrapper : ISyntaxWrapper + internal partial struct PropertyPatternClauseSyntaxWrapper : ISyntaxWrapper { - internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax"; - private static readonly Type WrappedType; - private static readonly Func OpenBraceTokenAccessor; private static readonly Func> SubpatternsAccessor; private static readonly Func CloseBraceTokenAccessor; @@ -20,8 +17,6 @@ internal struct PropertyPatternClauseSyntaxWrapper : ISyntaxWrapper, CSharpSyntaxNode> WithSubpatternsAccessor; private static readonly Func WithCloseBraceTokenAccessor; - private readonly CSharpSyntaxNode node; - static PropertyPatternClauseSyntaxWrapper() { WrappedType = WrapperHelper.GetWrappedType(typeof(PropertyPatternClauseSyntaxWrapper)); @@ -34,13 +29,6 @@ static PropertyPatternClauseSyntaxWrapper() WithCloseBraceTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(CloseBraceToken)); } - private PropertyPatternClauseSyntaxWrapper(CSharpSyntaxNode node) - { - this.node = node; - } - - public CSharpSyntaxNode SyntaxNode => this.node; - public SyntaxToken OpenBraceToken { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RangeExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RangeExpressionSyntaxWrapper.cs index 32afcde4eb..fc811abc0c 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RangeExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RangeExpressionSyntaxWrapper.cs @@ -7,11 +7,8 @@ namespace StyleCop.Analyzers.Lightup using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp.Syntax; - internal struct RangeExpressionSyntaxWrapper : ISyntaxWrapper + internal partial struct RangeExpressionSyntaxWrapper : ISyntaxWrapper { - internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax"; - private static readonly Type WrappedType; - private static readonly Func LeftOperandAccessor; private static readonly Func OperatorTokenAccessor; private static readonly Func RightOperandAccessor; @@ -20,8 +17,6 @@ internal struct RangeExpressionSyntaxWrapper : ISyntaxWrapper private static readonly Func WithOperatorTokenAccessor; private static readonly Func WithRightOperandAccessor; - private readonly ExpressionSyntax node; - static RangeExpressionSyntaxWrapper() { WrappedType = WrapperHelper.GetWrappedType(typeof(RangeExpressionSyntaxWrapper)); @@ -34,13 +29,6 @@ static RangeExpressionSyntaxWrapper() WithRightOperandAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(RightOperand)); } - private RangeExpressionSyntaxWrapper(ExpressionSyntax node) - { - this.node = node; - } - - public ExpressionSyntax SyntaxNode => this.node; - public ExpressionSyntax LeftOperand { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RecursivePatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RecursivePatternSyntaxWrapper.cs index 2a3f695db9..1ff4725ea3 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RecursivePatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RecursivePatternSyntaxWrapper.cs @@ -8,11 +8,8 @@ namespace StyleCop.Analyzers.Lightup using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.CSharp.Syntax; - internal struct RecursivePatternSyntaxWrapper : ISyntaxWrapper + internal partial struct RecursivePatternSyntaxWrapper : ISyntaxWrapper { - internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax"; - private static readonly Type WrappedType; - private static readonly Func TypeAccessor; private static readonly Func PositionalPatternClauseAccessor; private static readonly Func PropertyPatternClauseAccessor; @@ -23,8 +20,6 @@ internal struct RecursivePatternSyntaxWrapper : ISyntaxWrapper private static readonly Func WithPropertyPatternClauseAccessor; private static readonly Func WithDesignationAccessor; - private readonly CSharpSyntaxNode node; - static RecursivePatternSyntaxWrapper() { WrappedType = WrapperHelper.GetWrappedType(typeof(RecursivePatternSyntaxWrapper)); @@ -39,13 +34,6 @@ static RecursivePatternSyntaxWrapper() WithDesignationAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Designation)); } - private RecursivePatternSyntaxWrapper(CSharpSyntaxNode node) - { - this.node = node; - } - - public CSharpSyntaxNode SyntaxNode => this.node; - public TypeSyntax Type { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefExpressionSyntaxWrapper.cs index f85f9c3341..917a03b650 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefExpressionSyntaxWrapper.cs @@ -7,18 +7,13 @@ namespace StyleCop.Analyzers.Lightup using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp.Syntax; - internal struct RefExpressionSyntaxWrapper : ISyntaxWrapper + internal partial struct RefExpressionSyntaxWrapper : ISyntaxWrapper { - internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax"; - private static readonly Type WrappedType; - private static readonly Func RefKeywordAccessor; private static readonly Func ExpressionAccessor; private static readonly Func WithRefKeywordAccessor; private static readonly Func WithExpressionAccessor; - private readonly ExpressionSyntax node; - static RefExpressionSyntaxWrapper() { WrappedType = WrapperHelper.GetWrappedType(typeof(RefExpressionSyntaxWrapper)); @@ -28,13 +23,6 @@ static RefExpressionSyntaxWrapper() WithExpressionAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Expression)); } - private RefExpressionSyntaxWrapper(ExpressionSyntax node) - { - this.node = node; - } - - public ExpressionSyntax SyntaxNode => this.node; - public SyntaxToken RefKeyword { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefTypeSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefTypeSyntaxWrapper.cs index 356cb25e79..c2c44f562d 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefTypeSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefTypeSyntaxWrapper.cs @@ -7,11 +7,8 @@ namespace StyleCop.Analyzers.Lightup using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp.Syntax; - internal struct RefTypeSyntaxWrapper : ISyntaxWrapper + internal partial struct RefTypeSyntaxWrapper : ISyntaxWrapper { - internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax"; - private static readonly Type WrappedType; - private static readonly Func RefKeywordAccessor; private static readonly Func ReadOnlyKeywordAccessor; private static readonly Func TypeAccessor; @@ -19,8 +16,6 @@ internal struct RefTypeSyntaxWrapper : ISyntaxWrapper private static readonly Func WithReadOnlyKeywordAccessor; private static readonly Func WithTypeAccessor; - private readonly TypeSyntax node; - static RefTypeSyntaxWrapper() { WrappedType = WrapperHelper.GetWrappedType(typeof(RefTypeSyntaxWrapper)); @@ -32,13 +27,6 @@ static RefTypeSyntaxWrapper() WithTypeAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Type)); } - private RefTypeSyntaxWrapper(TypeSyntax node) - { - this.node = node; - } - - public TypeSyntax SyntaxNode => this.node; - public SyntaxToken RefKeyword { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SingleVariableDesignationSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SingleVariableDesignationSyntaxWrapper.cs index 518e4cea69..bbedc69a33 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SingleVariableDesignationSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SingleVariableDesignationSyntaxWrapper.cs @@ -7,16 +7,11 @@ namespace StyleCop.Analyzers.Lightup using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; - internal struct SingleVariableDesignationSyntaxWrapper : ISyntaxWrapper + internal partial struct SingleVariableDesignationSyntaxWrapper : ISyntaxWrapper { - internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax"; - private static readonly Type WrappedType; - private static readonly Func IdentifierAccessor; private static readonly Func WithIdentifierAccessor; - private readonly CSharpSyntaxNode node; - static SingleVariableDesignationSyntaxWrapper() { WrappedType = WrapperHelper.GetWrappedType(typeof(SingleVariableDesignationSyntaxWrapper)); @@ -24,13 +19,6 @@ static SingleVariableDesignationSyntaxWrapper() WithIdentifierAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Identifier)); } - private SingleVariableDesignationSyntaxWrapper(CSharpSyntaxNode node) - { - this.node = node; - } - - public CSharpSyntaxNode SyntaxNode => this.node; - public SyntaxToken Identifier { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SubpatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SubpatternSyntaxWrapper.cs index 4eb82a3431..98a229443c 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SubpatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SubpatternSyntaxWrapper.cs @@ -8,19 +8,14 @@ namespace StyleCop.Analyzers.Lightup using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.CSharp.Syntax; - internal struct SubpatternSyntaxWrapper : ISyntaxWrapper + internal partial struct SubpatternSyntaxWrapper : ISyntaxWrapper { - internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax"; - private static readonly Type WrappedType; - private static readonly Func NameColonAccessor; private static readonly Func PatternAccessor; private static readonly Func WithNameColonAccessor; private static readonly Func WithPatternAccessor; - private readonly CSharpSyntaxNode node; - static SubpatternSyntaxWrapper() { WrappedType = WrapperHelper.GetWrappedType(typeof(SubpatternSyntaxWrapper)); @@ -31,13 +26,6 @@ static SubpatternSyntaxWrapper() WithPatternAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Pattern)); } - private SubpatternSyntaxWrapper(CSharpSyntaxNode node) - { - this.node = node; - } - - public CSharpSyntaxNode SyntaxNode => this.node; - public NameColonSyntax NameColon { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionArmSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionArmSyntaxWrapper.cs index b7464c006b..a223b04883 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionArmSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionArmSyntaxWrapper.cs @@ -8,11 +8,8 @@ namespace StyleCop.Analyzers.Lightup using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.CSharp.Syntax; - internal struct SwitchExpressionArmSyntaxWrapper : ISyntaxWrapper + internal partial struct SwitchExpressionArmSyntaxWrapper : ISyntaxWrapper { - internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax"; - - private static readonly Type WrappedType; private static readonly Func PatternAccessor; private static readonly Func WhenClauseAccessor; private static readonly Func ExpressionAccessor; @@ -23,8 +20,6 @@ internal struct SwitchExpressionArmSyntaxWrapper : ISyntaxWrapper WithExpressionAccessor; private static readonly Func WithEqualsGreaterThanTokenAccessor; - private readonly CSharpSyntaxNode node; - static SwitchExpressionArmSyntaxWrapper() { WrappedType = WrapperHelper.GetWrappedType(typeof(SwitchExpressionArmSyntaxWrapper)); @@ -39,13 +34,6 @@ static SwitchExpressionArmSyntaxWrapper() WithEqualsGreaterThanTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(EqualsGreaterThanToken)); } - private SwitchExpressionArmSyntaxWrapper(CSharpSyntaxNode node) - { - this.node = node; - } - - public CSharpSyntaxNode SyntaxNode => this.node; - public PatternSyntaxWrapper Pattern { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionSyntaxWrapper.cs index a0cc138414..ca629495a1 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionSyntaxWrapper.cs @@ -7,11 +7,8 @@ namespace StyleCop.Analyzers.Lightup using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp.Syntax; - internal struct SwitchExpressionSyntaxWrapper : ISyntaxWrapper + internal partial struct SwitchExpressionSyntaxWrapper : ISyntaxWrapper { - internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax"; - - private static readonly Type WrappedType; private static readonly Func> ArmsAccessor; private static readonly Func GoverningExpressionAccessor; private static readonly Func OpenBraceTokenAccessor; @@ -24,8 +21,6 @@ internal struct SwitchExpressionSyntaxWrapper : ISyntaxWrapper private static readonly Func WithSwitchKeywordAccessor; private static readonly Func WithCloseBraceTokenAccessor; - private readonly ExpressionSyntax node; - static SwitchExpressionSyntaxWrapper() { WrappedType = WrapperHelper.GetWrappedType(typeof(SwitchExpressionSyntaxWrapper)); @@ -42,13 +37,6 @@ static SwitchExpressionSyntaxWrapper() WithCloseBraceTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(CloseBraceToken)); } - private SwitchExpressionSyntaxWrapper(ExpressionSyntax node) - { - this.node = node; - } - - public ExpressionSyntax SyntaxNode => this.node; - public ExpressionSyntax GoverningExpression { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ThrowExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ThrowExpressionSyntaxWrapper.cs index 50e5eeb93b..6b797712cf 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ThrowExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ThrowExpressionSyntaxWrapper.cs @@ -7,18 +7,13 @@ namespace StyleCop.Analyzers.Lightup using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp.Syntax; - internal struct ThrowExpressionSyntaxWrapper : ISyntaxWrapper + internal partial struct ThrowExpressionSyntaxWrapper : ISyntaxWrapper { - internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax"; - private static readonly Type WrappedType; - private static readonly Func ThrowKeywordAccessor; private static readonly Func ExpressionAccessor; private static readonly Func WithThrowKeywordAccessor; private static readonly Func WithExpressionAccessor; - private readonly ExpressionSyntax node; - static ThrowExpressionSyntaxWrapper() { WrappedType = WrapperHelper.GetWrappedType(typeof(ThrowExpressionSyntaxWrapper)); @@ -28,13 +23,6 @@ static ThrowExpressionSyntaxWrapper() WithExpressionAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Expression)); } - private ThrowExpressionSyntaxWrapper(ExpressionSyntax node) - { - this.node = node; - } - - public ExpressionSyntax SyntaxNode => this.node; - public SyntaxToken ThrowKeyword { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleElementSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleElementSyntaxWrapper.cs index 1b7fcf7b5c..96d7d89ca9 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleElementSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleElementSyntaxWrapper.cs @@ -8,18 +8,13 @@ namespace StyleCop.Analyzers.Lightup using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.CSharp.Syntax; - internal struct TupleElementSyntaxWrapper : ISyntaxWrapper + internal partial struct TupleElementSyntaxWrapper : ISyntaxWrapper { - internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax"; - private static readonly Type WrappedType; - private static readonly Func IdentifierAccessor; private static readonly Func TypeAccessor; private static readonly Func WithIdentifierAccessor; private static readonly Func WithTypeAccessor; - private readonly CSharpSyntaxNode node; - static TupleElementSyntaxWrapper() { WrappedType = WrapperHelper.GetWrappedType(typeof(TupleElementSyntaxWrapper)); @@ -29,13 +24,6 @@ static TupleElementSyntaxWrapper() WithTypeAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Type)); } - private TupleElementSyntaxWrapper(CSharpSyntaxNode node) - { - this.node = node; - } - - public CSharpSyntaxNode SyntaxNode => this.node; - public SyntaxToken Identifier { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleExpressionSyntaxWrapper.cs index a3278f1f4a..1d0198c43f 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleExpressionSyntaxWrapper.cs @@ -7,11 +7,8 @@ namespace StyleCop.Analyzers.Lightup using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp.Syntax; - internal struct TupleExpressionSyntaxWrapper : ISyntaxWrapper + internal partial struct TupleExpressionSyntaxWrapper : ISyntaxWrapper { - internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax"; - private static readonly Type WrappedType; - private static readonly Func OpenParenTokenAccessor; private static readonly Func> ArgumentsAccessor; private static readonly Func CloseParenTokenAccessor; @@ -19,8 +16,6 @@ internal struct TupleExpressionSyntaxWrapper : ISyntaxWrapper private static readonly Func, ExpressionSyntax> WithArgumentsAccessor; private static readonly Func WithCloseParenTokenAccessor; - private readonly ExpressionSyntax node; - static TupleExpressionSyntaxWrapper() { WrappedType = WrapperHelper.GetWrappedType(typeof(TupleExpressionSyntaxWrapper)); @@ -32,13 +27,6 @@ static TupleExpressionSyntaxWrapper() WithCloseParenTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(CloseParenToken)); } - private TupleExpressionSyntaxWrapper(ExpressionSyntax node) - { - this.node = node; - } - - public ExpressionSyntax SyntaxNode => this.node; - public SyntaxToken OpenParenToken { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleTypeSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleTypeSyntaxWrapper.cs index 1fa39b5214..34ee2def79 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleTypeSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleTypeSyntaxWrapper.cs @@ -7,11 +7,8 @@ namespace StyleCop.Analyzers.Lightup using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp.Syntax; - internal struct TupleTypeSyntaxWrapper : ISyntaxWrapper + internal partial struct TupleTypeSyntaxWrapper : ISyntaxWrapper { - internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax"; - private static readonly Type WrappedType; - private static readonly Func OpenParenTokenAccessor; private static readonly Func> ElementsAccessor; private static readonly Func CloseParenTokenAccessor; @@ -19,8 +16,6 @@ internal struct TupleTypeSyntaxWrapper : ISyntaxWrapper private static readonly Func, TypeSyntax> WithElementsAccessor; private static readonly Func WithCloseParenTokenAccessor; - private readonly TypeSyntax node; - static TupleTypeSyntaxWrapper() { WrappedType = WrapperHelper.GetWrappedType(typeof(TupleTypeSyntaxWrapper)); @@ -32,13 +27,6 @@ static TupleTypeSyntaxWrapper() WithCloseParenTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(CloseParenToken)); } - private TupleTypeSyntaxWrapper(TypeSyntax node) - { - this.node = node; - } - - public TypeSyntax SyntaxNode => this.node; - public SyntaxToken OpenParenToken { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VarPatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VarPatternSyntaxWrapper.cs index 23e74c92b3..2d60999377 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VarPatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VarPatternSyntaxWrapper.cs @@ -7,19 +7,14 @@ namespace StyleCop.Analyzers.Lightup using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; - internal struct VarPatternSyntaxWrapper : ISyntaxWrapper + internal partial struct VarPatternSyntaxWrapper : ISyntaxWrapper { - internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax"; - private static readonly Type WrappedType; - private static readonly Func VarKeywordAccessor; private static readonly Func DesignationAccessor; private static readonly Func WithVarKeywordAccessor; private static readonly Func WithDesignationAccessor; - private readonly CSharpSyntaxNode node; - static VarPatternSyntaxWrapper() { WrappedType = WrapperHelper.GetWrappedType(typeof(VarPatternSyntaxWrapper)); @@ -30,13 +25,6 @@ static VarPatternSyntaxWrapper() WithDesignationAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Designation)); } - private VarPatternSyntaxWrapper(CSharpSyntaxNode node) - { - this.node = node; - } - - public CSharpSyntaxNode SyntaxNode => this.node; - public SyntaxToken VarKeyword { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VariableDesignationSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VariableDesignationSyntaxWrapper.cs index 443c126e98..1678f594cb 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VariableDesignationSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VariableDesignationSyntaxWrapper.cs @@ -7,25 +7,13 @@ namespace StyleCop.Analyzers.Lightup using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; - internal struct VariableDesignationSyntaxWrapper : ISyntaxWrapper + internal partial struct VariableDesignationSyntaxWrapper : ISyntaxWrapper { - internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax"; - private static readonly Type WrappedType; - - private readonly CSharpSyntaxNode node; - static VariableDesignationSyntaxWrapper() { WrappedType = WrapperHelper.GetWrappedType(typeof(VariableDesignationSyntaxWrapper)); } - private VariableDesignationSyntaxWrapper(CSharpSyntaxNode node) - { - this.node = node; - } - - public CSharpSyntaxNode SyntaxNode => this.node; - public static explicit operator VariableDesignationSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/WhenClauseSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/WhenClauseSyntaxWrapper.cs index 6169fc1470..05bb662bee 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/WhenClauseSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/WhenClauseSyntaxWrapper.cs @@ -8,18 +8,13 @@ namespace StyleCop.Analyzers.Lightup using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.CSharp.Syntax; - internal struct WhenClauseSyntaxWrapper : ISyntaxWrapper + internal partial struct WhenClauseSyntaxWrapper : ISyntaxWrapper { - internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax"; - private static readonly Type WrappedType; - private static readonly Func WhenKeywordAccessor; private static readonly Func ConditionAccessor; private static readonly Func WithWhenKeywordAccessor; private static readonly Func WithConditionAccessor; - private readonly CSharpSyntaxNode node; - static WhenClauseSyntaxWrapper() { WrappedType = WrapperHelper.GetWrappedType(typeof(WhenClauseSyntaxWrapper)); @@ -29,13 +24,6 @@ static WhenClauseSyntaxWrapper() WithConditionAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Condition)); } - private WhenClauseSyntaxWrapper(CSharpSyntaxNode node) - { - this.node = node; - } - - public CSharpSyntaxNode SyntaxNode => this.node; - public SyntaxToken WhenKeyword { get From b1a97050fdaa4d9574be5dc0fbf99958837ba56d Mon Sep 17 00:00:00 2001 From: Sam Harwell Date: Fri, 13 Nov 2020 22:35:02 -0800 Subject: [PATCH 03/18] Generate implicit upcast and IsInstance --- .../SyntaxLightupGenerator.cs | 61 +++++++++++++++++++ ...ObjectCreationExpressionSyntaxWrapper.g.cs | 9 +++ .../BaseParameterSyntaxWrapper.g.cs | 9 +++ .../BinaryPatternSyntaxWrapper.g.cs | 9 +++ .../CasePatternSwitchLabelSyntaxWrapper.g.cs | 9 +++ .../CommonForEachStatementSyntaxWrapper.g.cs | 9 +++ .../ConstantPatternSyntaxWrapper.g.cs | 9 +++ .../DeclarationExpressionSyntaxWrapper.g.cs | 9 +++ .../DeclarationPatternSyntaxWrapper.g.cs | 9 +++ .../DefaultConstraintSyntaxWrapper.g.cs | 9 +++ .../DiscardDesignationSyntaxWrapper.g.cs | 9 +++ .../DiscardPatternSyntaxWrapper.g.cs | 9 +++ .../ExpressionOrPatternSyntaxWrapper.g.cs | 9 +++ ...ForEachVariableStatementSyntaxWrapper.g.cs | 9 +++ ...PointerCallingConventionSyntaxWrapper.g.cs | 9 +++ ...tionPointerParameterListSyntaxWrapper.g.cs | 9 +++ ...FunctionPointerParameterSyntaxWrapper.g.cs | 9 +++ .../FunctionPointerTypeSyntaxWrapper.g.cs | 9 +++ ...gedCallingConventionListSyntaxWrapper.g.cs | 9 +++ ...managedCallingConventionSyntaxWrapper.g.cs | 9 +++ ...ObjectCreationExpressionSyntaxWrapper.g.cs | 9 +++ ...cArrayCreationExpressionSyntaxWrapper.g.cs | 9 +++ .../IsPatternExpressionSyntaxWrapper.g.cs | 9 +++ .../LocalFunctionStatementSyntaxWrapper.g.cs | 9 +++ .../NullableDirectiveTriviaSyntaxWrapper.g.cs | 9 +++ .../ParenthesizedPatternSyntaxWrapper.g.cs | 9 +++ ...sizedVariableDesignationSyntaxWrapper.g.cs | 9 +++ .../PatternSyntaxWrapper.g.cs | 9 +++ .../PositionalPatternClauseSyntaxWrapper.g.cs | 9 +++ ...imaryConstructorBaseTypeSyntaxWrapper.g.cs | 9 +++ .../PropertyPatternClauseSyntaxWrapper.g.cs | 9 +++ .../RangeExpressionSyntaxWrapper.g.cs | 9 +++ .../RecordDeclarationSyntaxWrapper.g.cs | 9 +++ .../RecursivePatternSyntaxWrapper.g.cs | 9 +++ .../RefExpressionSyntaxWrapper.g.cs | 9 +++ .../RefTypeSyntaxWrapper.g.cs | 9 +++ .../RelationalPatternSyntaxWrapper.g.cs | 9 +++ ...ingleVariableDesignationSyntaxWrapper.g.cs | 9 +++ .../SubpatternSyntaxWrapper.g.cs | 9 +++ .../SwitchExpressionArmSyntaxWrapper.g.cs | 9 +++ .../SwitchExpressionSyntaxWrapper.g.cs | 9 +++ .../ThrowExpressionSyntaxWrapper.g.cs | 9 +++ .../TupleElementSyntaxWrapper.g.cs | 9 +++ .../TupleExpressionSyntaxWrapper.g.cs | 9 +++ .../TupleTypeSyntaxWrapper.g.cs | 9 +++ .../TypePatternSyntaxWrapper.g.cs | 9 +++ .../UnaryPatternSyntaxWrapper.g.cs | 9 +++ .../VarPatternSyntaxWrapper.g.cs | 9 +++ .../VariableDesignationSyntaxWrapper.g.cs | 9 +++ .../WhenClauseSyntaxWrapper.g.cs | 9 +++ .../WithExpressionSyntaxWrapper.g.cs | 9 +++ .../CasePatternSwitchLabelSyntaxWrapper.cs | 10 --- .../CommonForEachStatementSyntaxWrapper.cs | 10 --- .../Lightup/ConstantPatternSyntaxWrapper.cs | 10 --- .../DeclarationExpressionSyntaxWrapper.cs | 10 --- .../DeclarationPatternSyntaxWrapper.cs | 10 --- .../DiscardDesignationSyntaxWrapper.cs | 10 --- .../Lightup/DiscardPatternSyntaxWrapper.cs | 10 --- .../ForEachVariableStatementSyntaxWrapper.cs | 10 --- ...locArrayCreationExpressionSyntaxWrapper.cs | 10 --- .../IsPatternExpressionSyntaxWrapper.cs | 10 --- .../LocalFunctionStatementSyntaxWrapper.cs | 10 --- ...hesizedVariableDesignationSyntaxWrapper.cs | 10 --- .../Lightup/PatternSyntaxWrapper.cs | 10 --- .../PositionalPatternClauseSyntaxWrapper.cs | 10 --- .../PropertyPatternClauseSyntaxWrapper.cs | 10 --- .../Lightup/RangeExpressionSyntaxWrapper.cs | 10 --- .../Lightup/RecursivePatternSyntaxWrapper.cs | 10 --- .../Lightup/RefExpressionSyntaxWrapper.cs | 10 --- .../Lightup/RefTypeSyntaxWrapper.cs | 10 --- .../SingleVariableDesignationSyntaxWrapper.cs | 10 --- .../Lightup/SubpatternSyntaxWrapper.cs | 10 --- .../SwitchExpressionArmSyntaxWrapper.cs | 10 --- .../Lightup/SwitchExpressionSyntaxWrapper.cs | 10 --- .../Lightup/ThrowExpressionSyntaxWrapper.cs | 10 --- .../Lightup/TupleElementSyntaxWrapper.cs | 10 --- .../Lightup/TupleExpressionSyntaxWrapper.cs | 10 --- .../Lightup/TupleTypeSyntaxWrapper.cs | 10 --- .../Lightup/VarPatternSyntaxWrapper.cs | 10 --- .../VariableDesignationSyntaxWrapper.cs | 10 --- .../Lightup/WhenClauseSyntaxWrapper.cs | 10 --- 81 files changed, 511 insertions(+), 300 deletions(-) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs b/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs index 70b6ab5126..63e159ad41 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs @@ -126,6 +126,67 @@ private void GenerateSyntaxWrapper(in GeneratorExecutionContext context, SyntaxD initializer: null, semicolonToken: SyntaxFactory.Token(SyntaxKind.SemicolonToken))); + // public static implicit operator CSharpSyntaxNode(SyntaxWrapper wrapper) + // { + // return wrapper.node; + // } + members = members.Add(SyntaxFactory.ConversionOperatorDeclaration( + attributeLists: default, + modifiers: SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword), SyntaxFactory.Token(SyntaxKind.StaticKeyword)), + implicitOrExplicitKeyword: SyntaxFactory.Token(SyntaxKind.ImplicitKeyword), + operatorKeyword: SyntaxFactory.Token(SyntaxKind.OperatorKeyword), + type: SyntaxFactory.IdentifierName(concreteBase), + parameterList: SyntaxFactory.ParameterList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Parameter( + attributeLists: default, + modifiers: default, + type: SyntaxFactory.IdentifierName(nodeData.WrapperName), + identifier: SyntaxFactory.Identifier("wrapper"), + @default: null))), + body: SyntaxFactory.Block(SyntaxFactory.ReturnStatement(SyntaxFactory.MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + expression: SyntaxFactory.IdentifierName("wrapper"), + name: SyntaxFactory.IdentifierName("node")))), + expressionBody: null, + semicolonToken: default)); + + // public static bool IsInstance(SyntaxNode node) + // { + // return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + // } + members = members.Add(SyntaxFactory.MethodDeclaration( + attributeLists: default, + modifiers: SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword), SyntaxFactory.Token(SyntaxKind.StaticKeyword)), + returnType: SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.BoolKeyword)), + explicitInterfaceSpecifier: null, + identifier: SyntaxFactory.Identifier("IsInstance"), + typeParameterList: null, + parameterList: SyntaxFactory.ParameterList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Parameter( + attributeLists: default, + modifiers: default, + type: SyntaxFactory.IdentifierName("SyntaxNode"), + identifier: SyntaxFactory.Identifier("node"), + @default: null))), + constraintClauses: default, + body: SyntaxFactory.Block( + SyntaxFactory.ReturnStatement(SyntaxFactory.BinaryExpression( + SyntaxKind.LogicalAndExpression, + left: SyntaxFactory.BinaryExpression( + SyntaxKind.NotEqualsExpression, + left: SyntaxFactory.IdentifierName("node"), + right: SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)), + right: SyntaxFactory.InvocationExpression( + expression: SyntaxFactory.MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + expression: SyntaxFactory.IdentifierName("LightupHelpers"), + name: SyntaxFactory.IdentifierName("CanWrapNode")), + argumentList: SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList( + new[] + { + SyntaxFactory.Argument(SyntaxFactory.IdentifierName("node")), + SyntaxFactory.Argument(SyntaxFactory.IdentifierName("WrappedType")), + })))))), + expressionBody: null)); + var wrapperStruct = SyntaxFactory.StructDeclaration( attributeLists: default, modifiers: SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.InternalKeyword), SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword), SyntaxFactory.Token(SyntaxKind.PartialKeyword)), diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseObjectCreationExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseObjectCreationExpressionSyntaxWrapper.g.cs index ac9e9668e0..af8804e2ba 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseObjectCreationExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseObjectCreationExpressionSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private BaseObjectCreationExpressionSyntaxWrapper(ExpressionSyntax node) } public ExpressionSyntax SyntaxNode => this.node; + public static implicit operator ExpressionSyntax(BaseObjectCreationExpressionSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseParameterSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseParameterSyntaxWrapper.g.cs index 46128ab2e4..a53e41420a 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseParameterSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseParameterSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private BaseParameterSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static implicit operator CSharpSyntaxNode(BaseParameterSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BinaryPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BinaryPatternSyntaxWrapper.g.cs index a59a2bd188..b8028afc4d 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BinaryPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BinaryPatternSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private BinaryPatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static implicit operator CSharpSyntaxNode(BinaryPatternSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CasePatternSwitchLabelSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CasePatternSwitchLabelSyntaxWrapper.g.cs index 451a4e3778..5f5a71c46e 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CasePatternSwitchLabelSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CasePatternSwitchLabelSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private CasePatternSwitchLabelSyntaxWrapper(SwitchLabelSyntax node) } public SwitchLabelSyntax SyntaxNode => this.node; + public static implicit operator SwitchLabelSyntax(CasePatternSwitchLabelSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CommonForEachStatementSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CommonForEachStatementSyntaxWrapper.g.cs index 53409f8a32..75f26eff67 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CommonForEachStatementSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CommonForEachStatementSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private CommonForEachStatementSyntaxWrapper(StatementSyntax node) } public StatementSyntax SyntaxNode => this.node; + public static implicit operator StatementSyntax(CommonForEachStatementSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ConstantPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ConstantPatternSyntaxWrapper.g.cs index 7837fa3536..dc49aab18d 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ConstantPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ConstantPatternSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private ConstantPatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static implicit operator CSharpSyntaxNode(ConstantPatternSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationExpressionSyntaxWrapper.g.cs index 16c59c9eeb..d410f792a7 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationExpressionSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private DeclarationExpressionSyntaxWrapper(ExpressionSyntax node) } public ExpressionSyntax SyntaxNode => this.node; + public static implicit operator ExpressionSyntax(DeclarationExpressionSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationPatternSyntaxWrapper.g.cs index 7ed68637f9..4b102a1fcb 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationPatternSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private DeclarationPatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static implicit operator CSharpSyntaxNode(DeclarationPatternSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DefaultConstraintSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DefaultConstraintSyntaxWrapper.g.cs index 75aa657259..3dcb51c10e 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DefaultConstraintSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DefaultConstraintSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private DefaultConstraintSyntaxWrapper(TypeParameterConstraintSyntax node) } public TypeParameterConstraintSyntax SyntaxNode => this.node; + public static implicit operator TypeParameterConstraintSyntax(DefaultConstraintSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardDesignationSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardDesignationSyntaxWrapper.g.cs index 0f63f2a912..2e6acf8a93 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardDesignationSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardDesignationSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private DiscardDesignationSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static implicit operator CSharpSyntaxNode(DiscardDesignationSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardPatternSyntaxWrapper.g.cs index 38e8ac2b2e..8133cd951a 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardPatternSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private DiscardPatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static implicit operator CSharpSyntaxNode(DiscardPatternSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ExpressionOrPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ExpressionOrPatternSyntaxWrapper.g.cs index 30c86eef2d..e1817bf394 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ExpressionOrPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ExpressionOrPatternSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private ExpressionOrPatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static implicit operator CSharpSyntaxNode(ExpressionOrPatternSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ForEachVariableStatementSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ForEachVariableStatementSyntaxWrapper.g.cs index 91e74e7be8..b9ae77caae 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ForEachVariableStatementSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ForEachVariableStatementSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private ForEachVariableStatementSyntaxWrapper(StatementSyntax node) } public StatementSyntax SyntaxNode => this.node; + public static implicit operator StatementSyntax(ForEachVariableStatementSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerCallingConventionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerCallingConventionSyntaxWrapper.g.cs index 132d498f01..19068c3711 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerCallingConventionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerCallingConventionSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private FunctionPointerCallingConventionSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static implicit operator CSharpSyntaxNode(FunctionPointerCallingConventionSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterListSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterListSyntaxWrapper.g.cs index 647ec96dd0..38de4af132 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterListSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterListSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private FunctionPointerParameterListSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static implicit operator CSharpSyntaxNode(FunctionPointerParameterListSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterSyntaxWrapper.g.cs index a0952ecc7c..96998e6ec0 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private FunctionPointerParameterSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static implicit operator CSharpSyntaxNode(FunctionPointerParameterSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerTypeSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerTypeSyntaxWrapper.g.cs index 00c7f446a5..33df126323 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerTypeSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerTypeSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private FunctionPointerTypeSyntaxWrapper(TypeSyntax node) } public TypeSyntax SyntaxNode => this.node; + public static implicit operator TypeSyntax(FunctionPointerTypeSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionListSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionListSyntaxWrapper.g.cs index f664754586..f77e0c1cae 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionListSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionListSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private FunctionPointerUnmanagedCallingConventionListSyntaxWrapper(CSharpSyntaxN } public CSharpSyntaxNode SyntaxNode => this.node; + public static implicit operator CSharpSyntaxNode(FunctionPointerUnmanagedCallingConventionListSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionSyntaxWrapper.g.cs index 3046452ff6..75bbbd4a7a 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private FunctionPointerUnmanagedCallingConventionSyntaxWrapper(CSharpSyntaxNode } public CSharpSyntaxNode SyntaxNode => this.node; + public static implicit operator CSharpSyntaxNode(FunctionPointerUnmanagedCallingConventionSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitObjectCreationExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitObjectCreationExpressionSyntaxWrapper.g.cs index d2415e11c3..9accbfccfe 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitObjectCreationExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitObjectCreationExpressionSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private ImplicitObjectCreationExpressionSyntaxWrapper(ExpressionSyntax node) } public ExpressionSyntax SyntaxNode => this.node; + public static implicit operator ExpressionSyntax(ImplicitObjectCreationExpressionSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.g.cs index eb3ef15a37..2c19326258 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private ImplicitStackAllocArrayCreationExpressionSyntaxWrapper(ExpressionSyntax } public ExpressionSyntax SyntaxNode => this.node; + public static implicit operator ExpressionSyntax(ImplicitStackAllocArrayCreationExpressionSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/IsPatternExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/IsPatternExpressionSyntaxWrapper.g.cs index 94df227002..5c3b412295 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/IsPatternExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/IsPatternExpressionSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private IsPatternExpressionSyntaxWrapper(ExpressionSyntax node) } public ExpressionSyntax SyntaxNode => this.node; + public static implicit operator ExpressionSyntax(IsPatternExpressionSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/LocalFunctionStatementSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/LocalFunctionStatementSyntaxWrapper.g.cs index ca394dabdf..89ecf1fbf6 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/LocalFunctionStatementSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/LocalFunctionStatementSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private LocalFunctionStatementSyntaxWrapper(StatementSyntax node) } public StatementSyntax SyntaxNode => this.node; + public static implicit operator StatementSyntax(LocalFunctionStatementSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/NullableDirectiveTriviaSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/NullableDirectiveTriviaSyntaxWrapper.g.cs index f09864156b..c824cb27bc 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/NullableDirectiveTriviaSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/NullableDirectiveTriviaSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private NullableDirectiveTriviaSyntaxWrapper(DirectiveTriviaSyntax node) } public DirectiveTriviaSyntax SyntaxNode => this.node; + public static implicit operator DirectiveTriviaSyntax(NullableDirectiveTriviaSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedPatternSyntaxWrapper.g.cs index cf8227cee6..20391449e6 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedPatternSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private ParenthesizedPatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static implicit operator CSharpSyntaxNode(ParenthesizedPatternSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedVariableDesignationSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedVariableDesignationSyntaxWrapper.g.cs index a3653d134f..a7135cc680 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedVariableDesignationSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedVariableDesignationSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private ParenthesizedVariableDesignationSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static implicit operator CSharpSyntaxNode(ParenthesizedVariableDesignationSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PatternSyntaxWrapper.g.cs index 553db7d951..f7c71d9c64 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PatternSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private PatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static implicit operator CSharpSyntaxNode(PatternSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PositionalPatternClauseSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PositionalPatternClauseSyntaxWrapper.g.cs index 8abba461b6..44bbb16ce0 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PositionalPatternClauseSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PositionalPatternClauseSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private PositionalPatternClauseSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static implicit operator CSharpSyntaxNode(PositionalPatternClauseSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PrimaryConstructorBaseTypeSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PrimaryConstructorBaseTypeSyntaxWrapper.g.cs index a9488848e0..47c9a6c95c 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PrimaryConstructorBaseTypeSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PrimaryConstructorBaseTypeSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private PrimaryConstructorBaseTypeSyntaxWrapper(BaseTypeSyntax node) } public BaseTypeSyntax SyntaxNode => this.node; + public static implicit operator BaseTypeSyntax(PrimaryConstructorBaseTypeSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PropertyPatternClauseSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PropertyPatternClauseSyntaxWrapper.g.cs index 128e3b97af..a103d0819e 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PropertyPatternClauseSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PropertyPatternClauseSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private PropertyPatternClauseSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static implicit operator CSharpSyntaxNode(PropertyPatternClauseSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RangeExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RangeExpressionSyntaxWrapper.g.cs index 66cfa92f6d..20a5b4bc9e 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RangeExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RangeExpressionSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private RangeExpressionSyntaxWrapper(ExpressionSyntax node) } public ExpressionSyntax SyntaxNode => this.node; + public static implicit operator ExpressionSyntax(RangeExpressionSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecordDeclarationSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecordDeclarationSyntaxWrapper.g.cs index 27ee28139c..5f32f5c547 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecordDeclarationSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecordDeclarationSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private RecordDeclarationSyntaxWrapper(TypeDeclarationSyntax node) } public TypeDeclarationSyntax SyntaxNode => this.node; + public static implicit operator TypeDeclarationSyntax(RecordDeclarationSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecursivePatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecursivePatternSyntaxWrapper.g.cs index 9da6da793e..2a041abe0f 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecursivePatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecursivePatternSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private RecursivePatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static implicit operator CSharpSyntaxNode(RecursivePatternSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefExpressionSyntaxWrapper.g.cs index 486612e4bf..7bf10e2df5 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefExpressionSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private RefExpressionSyntaxWrapper(ExpressionSyntax node) } public ExpressionSyntax SyntaxNode => this.node; + public static implicit operator ExpressionSyntax(RefExpressionSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefTypeSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefTypeSyntaxWrapper.g.cs index a944410eb8..6042b038e3 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefTypeSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefTypeSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private RefTypeSyntaxWrapper(TypeSyntax node) } public TypeSyntax SyntaxNode => this.node; + public static implicit operator TypeSyntax(RefTypeSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RelationalPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RelationalPatternSyntaxWrapper.g.cs index 9d0ac681c7..b3f953a107 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RelationalPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RelationalPatternSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private RelationalPatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static implicit operator CSharpSyntaxNode(RelationalPatternSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SingleVariableDesignationSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SingleVariableDesignationSyntaxWrapper.g.cs index d8993920f1..7d5a4e27b8 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SingleVariableDesignationSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SingleVariableDesignationSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private SingleVariableDesignationSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static implicit operator CSharpSyntaxNode(SingleVariableDesignationSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SubpatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SubpatternSyntaxWrapper.g.cs index 49a19ac628..bc4e6a7397 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SubpatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SubpatternSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private SubpatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static implicit operator CSharpSyntaxNode(SubpatternSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionArmSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionArmSyntaxWrapper.g.cs index 09583e9221..9f63a4821c 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionArmSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionArmSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private SwitchExpressionArmSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static implicit operator CSharpSyntaxNode(SwitchExpressionArmSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionSyntaxWrapper.g.cs index 41e8e4fbbe..65fe896fd2 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private SwitchExpressionSyntaxWrapper(ExpressionSyntax node) } public ExpressionSyntax SyntaxNode => this.node; + public static implicit operator ExpressionSyntax(SwitchExpressionSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ThrowExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ThrowExpressionSyntaxWrapper.g.cs index 5b433b633b..8acb7bf499 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ThrowExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ThrowExpressionSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private ThrowExpressionSyntaxWrapper(ExpressionSyntax node) } public ExpressionSyntax SyntaxNode => this.node; + public static implicit operator ExpressionSyntax(ThrowExpressionSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleElementSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleElementSyntaxWrapper.g.cs index 613100c075..17eede1f1a 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleElementSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleElementSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private TupleElementSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static implicit operator CSharpSyntaxNode(TupleElementSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleExpressionSyntaxWrapper.g.cs index 398fffd99b..0f2671d496 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleExpressionSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private TupleExpressionSyntaxWrapper(ExpressionSyntax node) } public ExpressionSyntax SyntaxNode => this.node; + public static implicit operator ExpressionSyntax(TupleExpressionSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleTypeSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleTypeSyntaxWrapper.g.cs index aa9e2127a8..e3c1616796 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleTypeSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleTypeSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private TupleTypeSyntaxWrapper(TypeSyntax node) } public TypeSyntax SyntaxNode => this.node; + public static implicit operator TypeSyntax(TupleTypeSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TypePatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TypePatternSyntaxWrapper.g.cs index 5f4911584c..2494964c81 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TypePatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TypePatternSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private TypePatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static implicit operator CSharpSyntaxNode(TypePatternSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/UnaryPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/UnaryPatternSyntaxWrapper.g.cs index 3921620dc9..1251568414 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/UnaryPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/UnaryPatternSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private UnaryPatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static implicit operator CSharpSyntaxNode(UnaryPatternSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VarPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VarPatternSyntaxWrapper.g.cs index 1cefbaa0b1..2c30a988e0 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VarPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VarPatternSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private VarPatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static implicit operator CSharpSyntaxNode(VarPatternSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VariableDesignationSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VariableDesignationSyntaxWrapper.g.cs index 4b1836b860..a761ee0068 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VariableDesignationSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VariableDesignationSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private VariableDesignationSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static implicit operator CSharpSyntaxNode(VariableDesignationSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WhenClauseSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WhenClauseSyntaxWrapper.g.cs index 73047e8d13..aa4eb55e99 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WhenClauseSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WhenClauseSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private WhenClauseSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static implicit operator CSharpSyntaxNode(WhenClauseSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WithExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WithExpressionSyntaxWrapper.g.cs index 40ba2f7134..52f6d385ee 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WithExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WithExpressionSyntaxWrapper.g.cs @@ -20,5 +20,14 @@ private WithExpressionSyntaxWrapper(ExpressionSyntax node) } public ExpressionSyntax SyntaxNode => this.node; + public static implicit operator ExpressionSyntax(WithExpressionSyntaxWrapper wrapper) + { + return wrapper.node; + } + + public static bool IsInstance(SyntaxNode node) + { + return node != null && LightupHelpers.CanWrapNode(node, WrappedType); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CasePatternSwitchLabelSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CasePatternSwitchLabelSyntaxWrapper.cs index 718cd16c2d..1d7c918033 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CasePatternSwitchLabelSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CasePatternSwitchLabelSyntaxWrapper.cs @@ -59,16 +59,6 @@ public static explicit operator CasePatternSwitchLabelSyntaxWrapper(SyntaxNode n return new CasePatternSwitchLabelSyntaxWrapper((SwitchLabelSyntax)node); } - public static implicit operator SwitchLabelSyntax(CasePatternSwitchLabelSyntaxWrapper wrapper) - { - return wrapper.node; - } - - public static bool IsInstance(SyntaxNode node) - { - return node != null && LightupHelpers.CanWrapNode(node, WrappedType); - } - public CasePatternSwitchLabelSyntaxWrapper WithKeyword(SyntaxToken keyword) { return new CasePatternSwitchLabelSyntaxWrapper(WithKeywordAccessor(this.SyntaxNode, keyword)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CommonForEachStatementSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CommonForEachStatementSyntaxWrapper.cs index edf3f12c0d..c9c5bd8f83 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CommonForEachStatementSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CommonForEachStatementSyntaxWrapper.cs @@ -123,16 +123,6 @@ public static explicit operator CommonForEachStatementSyntaxWrapper(SyntaxNode n return new CommonForEachStatementSyntaxWrapper((StatementSyntax)node); } - public static implicit operator StatementSyntax(CommonForEachStatementSyntaxWrapper wrapper) - { - return wrapper.node; - } - - public static bool IsInstance(SyntaxNode node) - { - return node != null && LightupHelpers.CanWrapNode(node, WrappedType); - } - public CommonForEachStatementSyntaxWrapper WithAwaitKeyword(SyntaxToken awaitKeyword) { return new CommonForEachStatementSyntaxWrapper(WithAwaitKeywordAccessor(this.SyntaxNode, awaitKeyword)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ConstantPatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ConstantPatternSyntaxWrapper.cs index b558af1dc2..9ab56b97c9 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ConstantPatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ConstantPatternSyntaxWrapper.cs @@ -53,16 +53,6 @@ public static implicit operator PatternSyntaxWrapper(ConstantPatternSyntaxWrappe return PatternSyntaxWrapper.FromUpcast(wrapper.node); } - public static implicit operator CSharpSyntaxNode(ConstantPatternSyntaxWrapper wrapper) - { - return wrapper.node; - } - - public static bool IsInstance(SyntaxNode node) - { - return node != null && LightupHelpers.CanWrapNode(node, WrappedType); - } - public ConstantPatternSyntaxWrapper WithExpression(ExpressionSyntax expression) { return new ConstantPatternSyntaxWrapper(WithExpressionAccessor(this.SyntaxNode, expression)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationExpressionSyntaxWrapper.cs index 3c620bfae9..7c617574de 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationExpressionSyntaxWrapper.cs @@ -55,16 +55,6 @@ public static explicit operator DeclarationExpressionSyntaxWrapper(SyntaxNode no return new DeclarationExpressionSyntaxWrapper((ExpressionSyntax)node); } - public static implicit operator ExpressionSyntax(DeclarationExpressionSyntaxWrapper wrapper) - { - return wrapper.node; - } - - public static bool IsInstance(SyntaxNode node) - { - return node != null && LightupHelpers.CanWrapNode(node, WrappedType); - } - public DeclarationExpressionSyntaxWrapper WithType(TypeSyntax type) { return new DeclarationExpressionSyntaxWrapper(WithTypeAccessor(this.SyntaxNode, type)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationPatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationPatternSyntaxWrapper.cs index 04232eb19f..0f4fa4ce85 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationPatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationPatternSyntaxWrapper.cs @@ -65,16 +65,6 @@ public static implicit operator PatternSyntaxWrapper(DeclarationPatternSyntaxWra return PatternSyntaxWrapper.FromUpcast(wrapper.node); } - public static implicit operator CSharpSyntaxNode(DeclarationPatternSyntaxWrapper wrapper) - { - return wrapper.node; - } - - public static bool IsInstance(SyntaxNode node) - { - return node != null && LightupHelpers.CanWrapNode(node, WrappedType); - } - public DeclarationPatternSyntaxWrapper WithType(TypeSyntax type) { return new DeclarationPatternSyntaxWrapper(WithTypeAccessor(this.SyntaxNode, type)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardDesignationSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardDesignationSyntaxWrapper.cs index f257882c13..aa7ef4add4 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardDesignationSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardDesignationSyntaxWrapper.cs @@ -52,16 +52,6 @@ public static implicit operator VariableDesignationSyntaxWrapper(DiscardDesignat return VariableDesignationSyntaxWrapper.FromUpcast(wrapper.node); } - public static implicit operator CSharpSyntaxNode(DiscardDesignationSyntaxWrapper wrapper) - { - return wrapper.node; - } - - public static bool IsInstance(SyntaxNode node) - { - return node != null && LightupHelpers.CanWrapNode(node, WrappedType); - } - public DiscardDesignationSyntaxWrapper WithUnderscoreToken(SyntaxToken identifier) { return new DiscardDesignationSyntaxWrapper(WithUnderscoreTokenAccessor(this.SyntaxNode, identifier)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardPatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardPatternSyntaxWrapper.cs index f59a3f390f..9435f84b91 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardPatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardPatternSyntaxWrapper.cs @@ -52,16 +52,6 @@ public static implicit operator PatternSyntaxWrapper(DiscardPatternSyntaxWrapper return PatternSyntaxWrapper.FromUpcast(wrapper.node); } - public static implicit operator CSharpSyntaxNode(DiscardPatternSyntaxWrapper wrapper) - { - return wrapper.node; - } - - public static bool IsInstance(SyntaxNode node) - { - return node != null && LightupHelpers.CanWrapNode(node, WrappedType); - } - public DiscardPatternSyntaxWrapper WithUnderscoreToken(SyntaxToken identifier) { return new DiscardPatternSyntaxWrapper(WithUnderscoreTokenAccessor(this.SyntaxNode, identifier)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ForEachVariableStatementSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ForEachVariableStatementSyntaxWrapper.cs index 7f7ec15f9c..2bc572bcec 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ForEachVariableStatementSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ForEachVariableStatementSyntaxWrapper.cs @@ -124,16 +124,6 @@ public static implicit operator CommonForEachStatementSyntaxWrapper(ForEachVaria return CommonForEachStatementSyntaxWrapper.FromUpcast(wrapper.node); } - public static implicit operator StatementSyntax(ForEachVariableStatementSyntaxWrapper wrapper) - { - return wrapper.node; - } - - public static bool IsInstance(SyntaxNode node) - { - return node != null && LightupHelpers.CanWrapNode(node, WrappedType); - } - public ForEachVariableStatementSyntaxWrapper WithAwaitKeyword(SyntaxToken awaitKeyword) { return new ForEachVariableStatementSyntaxWrapper(WithAwaitKeywordAccessor(this.SyntaxNode, awaitKeyword)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.cs index b05e983ef1..2eaafa45c1 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.cs @@ -78,16 +78,6 @@ public static explicit operator ImplicitStackAllocArrayCreationExpressionSyntaxW return new ImplicitStackAllocArrayCreationExpressionSyntaxWrapper((ExpressionSyntax)node); } - public static implicit operator ExpressionSyntax(ImplicitStackAllocArrayCreationExpressionSyntaxWrapper wrapper) - { - return wrapper.node; - } - - public static bool IsInstance(SyntaxNode node) - { - return node != null && LightupHelpers.CanWrapNode(node, WrappedType); - } - public ImplicitStackAllocArrayCreationExpressionSyntaxWrapper WithStackAllocKeyword(SyntaxToken stackAllocKeyword) { return new ImplicitStackAllocArrayCreationExpressionSyntaxWrapper(WithStackAllocKeywordAccessor(this.SyntaxNode, stackAllocKeyword)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/IsPatternExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/IsPatternExpressionSyntaxWrapper.cs index 736d70a50f..150e63e3a4 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/IsPatternExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/IsPatternExpressionSyntaxWrapper.cs @@ -67,16 +67,6 @@ public static explicit operator IsPatternExpressionSyntaxWrapper(SyntaxNode node return new IsPatternExpressionSyntaxWrapper((ExpressionSyntax)node); } - public static implicit operator ExpressionSyntax(IsPatternExpressionSyntaxWrapper wrapper) - { - return wrapper.node; - } - - public static bool IsInstance(SyntaxNode node) - { - return node != null && LightupHelpers.CanWrapNode(node, WrappedType); - } - public IsPatternExpressionSyntaxWrapper WithExpression(ExpressionSyntax expression) { return new IsPatternExpressionSyntaxWrapper(WithExpressionAccessor(this.SyntaxNode, expression)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/LocalFunctionStatementSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/LocalFunctionStatementSyntaxWrapper.cs index 4272db18a0..1f6681af58 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/LocalFunctionStatementSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/LocalFunctionStatementSyntaxWrapper.cs @@ -139,16 +139,6 @@ public static explicit operator LocalFunctionStatementSyntaxWrapper(SyntaxNode n return new LocalFunctionStatementSyntaxWrapper((StatementSyntax)node); } - public static implicit operator StatementSyntax(LocalFunctionStatementSyntaxWrapper wrapper) - { - return wrapper.node; - } - - public static bool IsInstance(SyntaxNode node) - { - return node != null && LightupHelpers.CanWrapNode(node, WrappedType); - } - public LocalFunctionStatementSyntaxWrapper WithModifiers(SyntaxTokenList modifiers) { return new LocalFunctionStatementSyntaxWrapper(WithModifiersAccessor(this.SyntaxNode, modifiers)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ParenthesizedVariableDesignationSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ParenthesizedVariableDesignationSyntaxWrapper.cs index 2d46b9389f..164b4bf994 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ParenthesizedVariableDesignationSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ParenthesizedVariableDesignationSyntaxWrapper.cs @@ -76,16 +76,6 @@ public static implicit operator VariableDesignationSyntaxWrapper(ParenthesizedVa return VariableDesignationSyntaxWrapper.FromUpcast(wrapper.node); } - public static implicit operator CSharpSyntaxNode(ParenthesizedVariableDesignationSyntaxWrapper wrapper) - { - return wrapper.node; - } - - public static bool IsInstance(SyntaxNode node) - { - return node != null && LightupHelpers.CanWrapNode(node, WrappedType); - } - public ParenthesizedVariableDesignationSyntaxWrapper AddVariables(params VariableDesignationSyntaxWrapper[] items) { return new ParenthesizedVariableDesignationSyntaxWrapper(this.WithVariables(this.Variables.AddRange(items))); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PatternSyntaxWrapper.cs index 89b3186f8d..155965d07a 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PatternSyntaxWrapper.cs @@ -29,16 +29,6 @@ public static explicit operator PatternSyntaxWrapper(SyntaxNode node) return new PatternSyntaxWrapper((CSharpSyntaxNode)node); } - public static implicit operator CSharpSyntaxNode(PatternSyntaxWrapper wrapper) - { - return wrapper.node; - } - - public static bool IsInstance(SyntaxNode node) - { - return node != null && LightupHelpers.CanWrapNode(node, WrappedType); - } - internal static PatternSyntaxWrapper FromUpcast(CSharpSyntaxNode node) { return new PatternSyntaxWrapper(node); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PositionalPatternClauseSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PositionalPatternClauseSyntaxWrapper.cs index 2bcf31f167..5cb5f1b5af 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PositionalPatternClauseSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PositionalPatternClauseSyntaxWrapper.cs @@ -68,16 +68,6 @@ public static explicit operator PositionalPatternClauseSyntaxWrapper(SyntaxNode return new PositionalPatternClauseSyntaxWrapper((CSharpSyntaxNode)node); } - public static implicit operator CSharpSyntaxNode(PositionalPatternClauseSyntaxWrapper wrapper) - { - return wrapper.node; - } - - public static bool IsInstance(SyntaxNode node) - { - return node != null && LightupHelpers.CanWrapNode(node, WrappedType); - } - public PositionalPatternClauseSyntaxWrapper AddSubpatterns(params SubpatternSyntaxWrapper[] items) { return new PositionalPatternClauseSyntaxWrapper(this.WithSubpatterns(this.Subpatterns.AddRange(items))); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PropertyPatternClauseSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PropertyPatternClauseSyntaxWrapper.cs index dc058be1c8..fd601b1c43 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PropertyPatternClauseSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PropertyPatternClauseSyntaxWrapper.cs @@ -68,16 +68,6 @@ public static explicit operator PropertyPatternClauseSyntaxWrapper(SyntaxNode no return new PropertyPatternClauseSyntaxWrapper((CSharpSyntaxNode)node); } - public static implicit operator CSharpSyntaxNode(PropertyPatternClauseSyntaxWrapper wrapper) - { - return wrapper.node; - } - - public static bool IsInstance(SyntaxNode node) - { - return node != null && LightupHelpers.CanWrapNode(node, WrappedType); - } - public PropertyPatternClauseSyntaxWrapper AddSubpatterns(params SubpatternSyntaxWrapper[] items) { return new PropertyPatternClauseSyntaxWrapper(this.WithSubpatterns(this.Subpatterns.AddRange(items))); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RangeExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RangeExpressionSyntaxWrapper.cs index fc811abc0c..1998409a17 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RangeExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RangeExpressionSyntaxWrapper.cs @@ -68,16 +68,6 @@ public static explicit operator RangeExpressionSyntaxWrapper(ExpressionSyntax no return new RangeExpressionSyntaxWrapper((ExpressionSyntax)node); } - public static implicit operator ExpressionSyntax(RangeExpressionSyntaxWrapper wrapper) - { - return wrapper.node; - } - - public static bool IsInstance(SyntaxNode node) - { - return node != null && LightupHelpers.CanWrapNode(node, WrappedType); - } - public RangeExpressionSyntaxWrapper WithLeftOperand(ExpressionSyntax leftOperand) { return new RangeExpressionSyntaxWrapper(WithLeftOperandAccessor(this.SyntaxNode, leftOperand)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RecursivePatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RecursivePatternSyntaxWrapper.cs index 1ff4725ea3..712bf0d264 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RecursivePatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RecursivePatternSyntaxWrapper.cs @@ -91,16 +91,6 @@ public static implicit operator PatternSyntaxWrapper(RecursivePatternSyntaxWrapp return PatternSyntaxWrapper.FromUpcast(wrapper.node); } - public static implicit operator CSharpSyntaxNode(RecursivePatternSyntaxWrapper wrapper) - { - return wrapper.node; - } - - public static bool IsInstance(SyntaxNode node) - { - return node != null && LightupHelpers.CanWrapNode(node, WrappedType); - } - public RecursivePatternSyntaxWrapper AddPositionalPatternClauseSubpatterns(params SubpatternSyntaxWrapper[] items) { var positionalPatternClause = this.PositionalPatternClause; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefExpressionSyntaxWrapper.cs index 917a03b650..0c39c5e4c7 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefExpressionSyntaxWrapper.cs @@ -54,16 +54,6 @@ public static explicit operator RefExpressionSyntaxWrapper(SyntaxNode node) return new RefExpressionSyntaxWrapper((ExpressionSyntax)node); } - public static implicit operator ExpressionSyntax(RefExpressionSyntaxWrapper wrapper) - { - return wrapper.node; - } - - public static bool IsInstance(SyntaxNode node) - { - return node != null && LightupHelpers.CanWrapNode(node, WrappedType); - } - public RefExpressionSyntaxWrapper WithRefKeyword(SyntaxToken refKeyword) { return new RefExpressionSyntaxWrapper(WithRefKeywordAccessor(this.SyntaxNode, refKeyword)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefTypeSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefTypeSyntaxWrapper.cs index c2c44f562d..9dd46e8e68 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefTypeSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefTypeSyntaxWrapper.cs @@ -66,16 +66,6 @@ public static explicit operator RefTypeSyntaxWrapper(SyntaxNode node) return new RefTypeSyntaxWrapper((TypeSyntax)node); } - public static implicit operator TypeSyntax(RefTypeSyntaxWrapper wrapper) - { - return wrapper.node; - } - - public static bool IsInstance(SyntaxNode node) - { - return node != null && LightupHelpers.CanWrapNode(node, WrappedType); - } - public RefTypeSyntaxWrapper WithRefKeyword(SyntaxToken refKeyword) { return new RefTypeSyntaxWrapper(WithRefKeywordAccessor(this.SyntaxNode, refKeyword)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SingleVariableDesignationSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SingleVariableDesignationSyntaxWrapper.cs index bbedc69a33..5f51a593f6 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SingleVariableDesignationSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SingleVariableDesignationSyntaxWrapper.cs @@ -52,16 +52,6 @@ public static implicit operator VariableDesignationSyntaxWrapper(SingleVariableD return VariableDesignationSyntaxWrapper.FromUpcast(wrapper.node); } - public static implicit operator CSharpSyntaxNode(SingleVariableDesignationSyntaxWrapper wrapper) - { - return wrapper.node; - } - - public static bool IsInstance(SyntaxNode node) - { - return node != null && LightupHelpers.CanWrapNode(node, WrappedType); - } - public SingleVariableDesignationSyntaxWrapper WithIdentifier(SyntaxToken identifier) { return new SingleVariableDesignationSyntaxWrapper(WithIdentifierAccessor(this.SyntaxNode, identifier)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SubpatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SubpatternSyntaxWrapper.cs index 98a229443c..fbb86e5ca4 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SubpatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SubpatternSyntaxWrapper.cs @@ -57,16 +57,6 @@ public static explicit operator SubpatternSyntaxWrapper(SyntaxNode node) return new SubpatternSyntaxWrapper((CSharpSyntaxNode)node); } - public static implicit operator CSharpSyntaxNode(SubpatternSyntaxWrapper wrapper) - { - return wrapper.node; - } - - public static bool IsInstance(SyntaxNode node) - { - return node != null && LightupHelpers.CanWrapNode(node, WrappedType); - } - public SubpatternSyntaxWrapper WithNameColon(NameColonSyntax nameColon) { return new SubpatternSyntaxWrapper(WithNameColonAccessor(this.SyntaxNode, nameColon)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionArmSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionArmSyntaxWrapper.cs index a223b04883..710e50a4d0 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionArmSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionArmSyntaxWrapper.cs @@ -81,16 +81,6 @@ public static explicit operator SwitchExpressionArmSyntaxWrapper(SyntaxNode node return new SwitchExpressionArmSyntaxWrapper((CSharpSyntaxNode)node); } - public static implicit operator CSharpSyntaxNode(SwitchExpressionArmSyntaxWrapper wrapper) - { - return wrapper.node; - } - - public static bool IsInstance(SyntaxNode node) - { - return node != null && LightupHelpers.CanWrapNode(node, WrappedType); - } - public SwitchExpressionArmSyntaxWrapper WithPattern(PatternSyntaxWrapper pattern) { return new SwitchExpressionArmSyntaxWrapper(WithPatternAccessor(this.SyntaxNode, pattern.SyntaxNode)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionSyntaxWrapper.cs index ca629495a1..7bb0d40f3f 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionSyntaxWrapper.cs @@ -92,16 +92,6 @@ public static explicit operator SwitchExpressionSyntaxWrapper(SyntaxNode node) return new SwitchExpressionSyntaxWrapper((ExpressionSyntax)node); } - public static implicit operator ExpressionSyntax(SwitchExpressionSyntaxWrapper wrapper) - { - return wrapper.node; - } - - public static bool IsInstance(SyntaxNode node) - { - return node != null && LightupHelpers.CanWrapNode(node, WrappedType); - } - public SwitchExpressionSyntaxWrapper AddArms(params SwitchExpressionArmSyntaxWrapper[] arms) { return new SwitchExpressionSyntaxWrapper(this.WithArms(this.Arms.AddRange(arms))); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ThrowExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ThrowExpressionSyntaxWrapper.cs index 6b797712cf..bc43fc0e65 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ThrowExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ThrowExpressionSyntaxWrapper.cs @@ -54,16 +54,6 @@ public static explicit operator ThrowExpressionSyntaxWrapper(SyntaxNode node) return new ThrowExpressionSyntaxWrapper((ExpressionSyntax)node); } - public static implicit operator ExpressionSyntax(ThrowExpressionSyntaxWrapper wrapper) - { - return wrapper.node; - } - - public static bool IsInstance(SyntaxNode node) - { - return node != null && LightupHelpers.CanWrapNode(node, WrappedType); - } - public ThrowExpressionSyntaxWrapper WithThrowKeyword(SyntaxToken throwKeyword) { return new ThrowExpressionSyntaxWrapper(WithThrowKeywordAccessor(this.SyntaxNode, throwKeyword)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleElementSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleElementSyntaxWrapper.cs index 96d7d89ca9..55f64e9a9b 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleElementSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleElementSyntaxWrapper.cs @@ -55,16 +55,6 @@ public static explicit operator TupleElementSyntaxWrapper(SyntaxNode node) return new TupleElementSyntaxWrapper((CSharpSyntaxNode)node); } - public static implicit operator CSharpSyntaxNode(TupleElementSyntaxWrapper wrapper) - { - return wrapper.node; - } - - public static bool IsInstance(SyntaxNode node) - { - return node != null && LightupHelpers.CanWrapNode(node, WrappedType); - } - public TupleElementSyntaxWrapper WithIdentifier(SyntaxToken identifier) { return new TupleElementSyntaxWrapper(WithIdentifierAccessor(this.SyntaxNode, identifier)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleExpressionSyntaxWrapper.cs index 1d0198c43f..398345c71b 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleExpressionSyntaxWrapper.cs @@ -66,16 +66,6 @@ public static explicit operator TupleExpressionSyntaxWrapper(SyntaxNode node) return new TupleExpressionSyntaxWrapper((ExpressionSyntax)node); } - public static implicit operator ExpressionSyntax(TupleExpressionSyntaxWrapper wrapper) - { - return wrapper.node; - } - - public static bool IsInstance(SyntaxNode node) - { - return node != null && LightupHelpers.CanWrapNode(node, WrappedType); - } - public TupleExpressionSyntaxWrapper AddArguments(params ArgumentSyntax[] items) { return new TupleExpressionSyntaxWrapper(this.WithArguments(this.Arguments.AddRange(items))); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleTypeSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleTypeSyntaxWrapper.cs index 34ee2def79..a9544f40cf 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleTypeSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleTypeSyntaxWrapper.cs @@ -66,16 +66,6 @@ public static explicit operator TupleTypeSyntaxWrapper(SyntaxNode node) return new TupleTypeSyntaxWrapper((TypeSyntax)node); } - public static implicit operator TypeSyntax(TupleTypeSyntaxWrapper wrapper) - { - return wrapper.node; - } - - public static bool IsInstance(SyntaxNode node) - { - return node != null && LightupHelpers.CanWrapNode(node, WrappedType); - } - public TupleTypeSyntaxWrapper AddElements(params TupleElementSyntaxWrapper[] items) { return new TupleTypeSyntaxWrapper(this.WithElements(this.Elements.AddRange(items))); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VarPatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VarPatternSyntaxWrapper.cs index 2d60999377..809a8263ae 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VarPatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VarPatternSyntaxWrapper.cs @@ -66,16 +66,6 @@ public static implicit operator PatternSyntaxWrapper(VarPatternSyntaxWrapper wra return PatternSyntaxWrapper.FromUpcast(wrapper.node); } - public static implicit operator CSharpSyntaxNode(VarPatternSyntaxWrapper wrapper) - { - return wrapper.node; - } - - public static bool IsInstance(SyntaxNode node) - { - return node != null && LightupHelpers.CanWrapNode(node, WrappedType); - } - public VarPatternSyntaxWrapper WithVarKeyword(SyntaxToken varKeyword) { return new VarPatternSyntaxWrapper(WithVarKeywordAccessor(this.SyntaxNode, varKeyword)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VariableDesignationSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VariableDesignationSyntaxWrapper.cs index 1678f594cb..6c920befea 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VariableDesignationSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VariableDesignationSyntaxWrapper.cs @@ -29,16 +29,6 @@ public static explicit operator VariableDesignationSyntaxWrapper(SyntaxNode node return new VariableDesignationSyntaxWrapper((CSharpSyntaxNode)node); } - public static implicit operator CSharpSyntaxNode(VariableDesignationSyntaxWrapper wrapper) - { - return wrapper.node; - } - - public static bool IsInstance(SyntaxNode node) - { - return node != null && LightupHelpers.CanWrapNode(node, WrappedType); - } - internal static VariableDesignationSyntaxWrapper FromUpcast(CSharpSyntaxNode node) { return new VariableDesignationSyntaxWrapper(node); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/WhenClauseSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/WhenClauseSyntaxWrapper.cs index 05bb662bee..9ebded8746 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/WhenClauseSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/WhenClauseSyntaxWrapper.cs @@ -55,16 +55,6 @@ public static explicit operator WhenClauseSyntaxWrapper(SyntaxNode node) return new WhenClauseSyntaxWrapper((CSharpSyntaxNode)node); } - public static implicit operator CSharpSyntaxNode(WhenClauseSyntaxWrapper wrapper) - { - return wrapper.node; - } - - public static bool IsInstance(SyntaxNode node) - { - return node != null && LightupHelpers.CanWrapNode(node, WrappedType); - } - public WhenClauseSyntaxWrapper WithWhenKeyword(SyntaxToken whenKeyword) { return new WhenClauseSyntaxWrapper(WithWhenKeywordAccessor(this.SyntaxNode, whenKeyword)); From 147568c29c9f7e53161e6dd8c141ce2380202adf Mon Sep 17 00:00:00 2001 From: Sam Harwell Date: Fri, 13 Nov 2020 22:44:24 -0800 Subject: [PATCH 04/18] Generate explicit downcast --- .../SyntaxLightupGenerator.cs | 88 +++++++++++++++++++ ...ObjectCreationExpressionSyntaxWrapper.g.cs | 15 ++++ .../BaseParameterSyntaxWrapper.g.cs | 15 ++++ .../BinaryPatternSyntaxWrapper.g.cs | 15 ++++ .../CasePatternSwitchLabelSyntaxWrapper.g.cs | 15 ++++ .../CommonForEachStatementSyntaxWrapper.g.cs | 15 ++++ .../ConstantPatternSyntaxWrapper.g.cs | 15 ++++ .../DeclarationExpressionSyntaxWrapper.g.cs | 15 ++++ .../DeclarationPatternSyntaxWrapper.g.cs | 15 ++++ .../DefaultConstraintSyntaxWrapper.g.cs | 15 ++++ .../DiscardDesignationSyntaxWrapper.g.cs | 15 ++++ .../DiscardPatternSyntaxWrapper.g.cs | 15 ++++ .../ExpressionOrPatternSyntaxWrapper.g.cs | 15 ++++ ...ForEachVariableStatementSyntaxWrapper.g.cs | 15 ++++ ...PointerCallingConventionSyntaxWrapper.g.cs | 15 ++++ ...tionPointerParameterListSyntaxWrapper.g.cs | 15 ++++ ...FunctionPointerParameterSyntaxWrapper.g.cs | 15 ++++ .../FunctionPointerTypeSyntaxWrapper.g.cs | 15 ++++ ...gedCallingConventionListSyntaxWrapper.g.cs | 15 ++++ ...managedCallingConventionSyntaxWrapper.g.cs | 15 ++++ ...ObjectCreationExpressionSyntaxWrapper.g.cs | 15 ++++ ...cArrayCreationExpressionSyntaxWrapper.g.cs | 15 ++++ .../IsPatternExpressionSyntaxWrapper.g.cs | 15 ++++ .../LocalFunctionStatementSyntaxWrapper.g.cs | 15 ++++ .../NullableDirectiveTriviaSyntaxWrapper.g.cs | 15 ++++ .../ParenthesizedPatternSyntaxWrapper.g.cs | 15 ++++ ...sizedVariableDesignationSyntaxWrapper.g.cs | 15 ++++ .../PatternSyntaxWrapper.g.cs | 15 ++++ .../PositionalPatternClauseSyntaxWrapper.g.cs | 15 ++++ ...imaryConstructorBaseTypeSyntaxWrapper.g.cs | 15 ++++ .../PropertyPatternClauseSyntaxWrapper.g.cs | 15 ++++ .../RangeExpressionSyntaxWrapper.g.cs | 15 ++++ .../RecordDeclarationSyntaxWrapper.g.cs | 15 ++++ .../RecursivePatternSyntaxWrapper.g.cs | 15 ++++ .../RefExpressionSyntaxWrapper.g.cs | 15 ++++ .../RefTypeSyntaxWrapper.g.cs | 15 ++++ .../RelationalPatternSyntaxWrapper.g.cs | 15 ++++ ...ingleVariableDesignationSyntaxWrapper.g.cs | 15 ++++ .../SubpatternSyntaxWrapper.g.cs | 15 ++++ .../SwitchExpressionArmSyntaxWrapper.g.cs | 15 ++++ .../SwitchExpressionSyntaxWrapper.g.cs | 15 ++++ .../ThrowExpressionSyntaxWrapper.g.cs | 15 ++++ .../TupleElementSyntaxWrapper.g.cs | 15 ++++ .../TupleExpressionSyntaxWrapper.g.cs | 15 ++++ .../TupleTypeSyntaxWrapper.g.cs | 15 ++++ .../TypePatternSyntaxWrapper.g.cs | 15 ++++ .../UnaryPatternSyntaxWrapper.g.cs | 15 ++++ .../VarPatternSyntaxWrapper.g.cs | 15 ++++ .../VariableDesignationSyntaxWrapper.g.cs | 15 ++++ .../WhenClauseSyntaxWrapper.g.cs | 15 ++++ .../WithExpressionSyntaxWrapper.g.cs | 15 ++++ .../CasePatternSwitchLabelSyntaxWrapper.cs | 15 ---- .../CommonForEachStatementSyntaxWrapper.cs | 15 ---- .../Lightup/ConstantPatternSyntaxWrapper.cs | 15 ---- .../DeclarationExpressionSyntaxWrapper.cs | 15 ---- .../DeclarationPatternSyntaxWrapper.cs | 15 ---- .../DiscardDesignationSyntaxWrapper.cs | 15 ---- .../Lightup/DiscardPatternSyntaxWrapper.cs | 15 ---- .../ForEachVariableStatementSyntaxWrapper.cs | 15 ---- ...locArrayCreationExpressionSyntaxWrapper.cs | 15 ---- .../IsPatternExpressionSyntaxWrapper.cs | 15 ---- .../LocalFunctionStatementSyntaxWrapper.cs | 15 ---- ...hesizedVariableDesignationSyntaxWrapper.cs | 15 ---- .../Lightup/PatternSyntaxWrapper.cs | 15 ---- .../PositionalPatternClauseSyntaxWrapper.cs | 15 ---- .../PropertyPatternClauseSyntaxWrapper.cs | 15 ---- .../Lightup/RangeExpressionSyntaxWrapper.cs | 15 ---- .../Lightup/RecursivePatternSyntaxWrapper.cs | 15 ---- .../Lightup/RefExpressionSyntaxWrapper.cs | 15 ---- .../Lightup/RefTypeSyntaxWrapper.cs | 15 ---- .../SingleVariableDesignationSyntaxWrapper.cs | 15 ---- .../Lightup/SubpatternSyntaxWrapper.cs | 15 ---- .../SwitchExpressionArmSyntaxWrapper.cs | 15 ---- .../Lightup/SwitchExpressionSyntaxWrapper.cs | 15 ---- .../Lightup/ThrowExpressionSyntaxWrapper.cs | 15 ---- .../Lightup/TupleElementSyntaxWrapper.cs | 15 ---- .../Lightup/TupleExpressionSyntaxWrapper.cs | 15 ---- .../Lightup/TupleTypeSyntaxWrapper.cs | 15 ---- .../Lightup/VarPatternSyntaxWrapper.cs | 15 ---- .../VariableDesignationSyntaxWrapper.cs | 15 ---- .../Lightup/WhenClauseSyntaxWrapper.cs | 15 ---- 81 files changed, 838 insertions(+), 450 deletions(-) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs b/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs index 63e159ad41..d3243ed791 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs @@ -126,6 +126,94 @@ private void GenerateSyntaxWrapper(in GeneratorExecutionContext context, SyntaxD initializer: null, semicolonToken: SyntaxFactory.Token(SyntaxKind.SemicolonToken))); + // public static explicit operator WhenClauseSyntaxWrapper(SyntaxNode node) + // { + // if (node == null) + // { + // return default; + // } + // + // if (!IsInstance(node)) + // { + // throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + // } + // + // return new WhenClauseSyntaxWrapper((CSharpSyntaxNode)node); + // } + members = members.Add(SyntaxFactory.ConversionOperatorDeclaration( + attributeLists: default, + modifiers: SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword), SyntaxFactory.Token(SyntaxKind.StaticKeyword)), + implicitOrExplicitKeyword: SyntaxFactory.Token(SyntaxKind.ExplicitKeyword), + operatorKeyword: SyntaxFactory.Token(SyntaxKind.OperatorKeyword), + type: SyntaxFactory.IdentifierName(nodeData.WrapperName), + parameterList: SyntaxFactory.ParameterList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Parameter( + attributeLists: default, + modifiers: default, + type: SyntaxFactory.IdentifierName("SyntaxNode"), + identifier: SyntaxFactory.Identifier("node"), + @default: null))), + body: SyntaxFactory.Block( + SyntaxFactory.IfStatement( + condition: SyntaxFactory.BinaryExpression( + SyntaxKind.EqualsExpression, + left: SyntaxFactory.IdentifierName("node"), + right: SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)), + statement: SyntaxFactory.Block( + SyntaxFactory.ReturnStatement(SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression)))), + SyntaxFactory.IfStatement( + condition: SyntaxFactory.PrefixUnaryExpression( + SyntaxKind.LogicalNotExpression, + operand: SyntaxFactory.InvocationExpression( + expression: SyntaxFactory.IdentifierName("IsInstance"), + argumentList: SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Argument(SyntaxFactory.IdentifierName("node")))))), + statement: SyntaxFactory.Block( + SyntaxFactory.ThrowStatement(SyntaxFactory.ObjectCreationExpression( + type: SyntaxFactory.IdentifierName("InvalidCastException"), + argumentList: SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Argument( + SyntaxFactory.InterpolatedStringExpression( + SyntaxFactory.Token(SyntaxKind.InterpolatedStringStartToken), + SyntaxFactory.List(new InterpolatedStringContentSyntax[] + { + SyntaxFactory.InterpolatedStringText(SyntaxFactory.Token( + leading: default, + SyntaxKind.InterpolatedStringTextToken, + "Cannot cast '", + "Cannot cast '", + trailing: default)), + SyntaxFactory.Interpolation(SyntaxFactory.MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + expression: SyntaxFactory.InvocationExpression( + expression: SyntaxFactory.MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + expression: SyntaxFactory.IdentifierName("node"), + name: SyntaxFactory.IdentifierName("GetType")), + argumentList: SyntaxFactory.ArgumentList()), + name: SyntaxFactory.IdentifierName("FullName"))), + SyntaxFactory.InterpolatedStringText(SyntaxFactory.Token( + leading: default, + SyntaxKind.InterpolatedStringTextToken, + "' to '", + "' to '", + trailing: default)), + SyntaxFactory.Interpolation(SyntaxFactory.IdentifierName("WrappedTypeName")), + SyntaxFactory.InterpolatedStringText(SyntaxFactory.Token( + leading: default, + SyntaxKind.InterpolatedStringTextToken, + "'", + "'", + trailing: default)), + }))))), + initializer: null)))), + SyntaxFactory.ReturnStatement(SyntaxFactory.ObjectCreationExpression( + type: SyntaxFactory.IdentifierName(nodeData.WrapperName), + argumentList: SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Argument( + SyntaxFactory.CastExpression( + type: SyntaxFactory.IdentifierName(concreteBase), + expression: SyntaxFactory.IdentifierName("node"))))), + initializer: null))), + expressionBody: null, + semicolonToken: default)); + // public static implicit operator CSharpSyntaxNode(SyntaxWrapper wrapper) // { // return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseObjectCreationExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseObjectCreationExpressionSyntaxWrapper.g.cs index af8804e2ba..53906c41d8 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseObjectCreationExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseObjectCreationExpressionSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private BaseObjectCreationExpressionSyntaxWrapper(ExpressionSyntax node) } public ExpressionSyntax SyntaxNode => this.node; + public static explicit operator BaseObjectCreationExpressionSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new BaseObjectCreationExpressionSyntaxWrapper((ExpressionSyntax)node); + } + public static implicit operator ExpressionSyntax(BaseObjectCreationExpressionSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseParameterSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseParameterSyntaxWrapper.g.cs index a53e41420a..6c501eb18d 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseParameterSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseParameterSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private BaseParameterSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static explicit operator BaseParameterSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new BaseParameterSyntaxWrapper((CSharpSyntaxNode)node); + } + public static implicit operator CSharpSyntaxNode(BaseParameterSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BinaryPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BinaryPatternSyntaxWrapper.g.cs index b8028afc4d..03cd04e216 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BinaryPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BinaryPatternSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private BinaryPatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static explicit operator BinaryPatternSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new BinaryPatternSyntaxWrapper((CSharpSyntaxNode)node); + } + public static implicit operator CSharpSyntaxNode(BinaryPatternSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CasePatternSwitchLabelSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CasePatternSwitchLabelSyntaxWrapper.g.cs index 5f5a71c46e..2624d95e95 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CasePatternSwitchLabelSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CasePatternSwitchLabelSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private CasePatternSwitchLabelSyntaxWrapper(SwitchLabelSyntax node) } public SwitchLabelSyntax SyntaxNode => this.node; + public static explicit operator CasePatternSwitchLabelSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new CasePatternSwitchLabelSyntaxWrapper((SwitchLabelSyntax)node); + } + public static implicit operator SwitchLabelSyntax(CasePatternSwitchLabelSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CommonForEachStatementSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CommonForEachStatementSyntaxWrapper.g.cs index 75f26eff67..383436e52e 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CommonForEachStatementSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CommonForEachStatementSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private CommonForEachStatementSyntaxWrapper(StatementSyntax node) } public StatementSyntax SyntaxNode => this.node; + public static explicit operator CommonForEachStatementSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new CommonForEachStatementSyntaxWrapper((StatementSyntax)node); + } + public static implicit operator StatementSyntax(CommonForEachStatementSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ConstantPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ConstantPatternSyntaxWrapper.g.cs index dc49aab18d..b2aa8a0ada 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ConstantPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ConstantPatternSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private ConstantPatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static explicit operator ConstantPatternSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new ConstantPatternSyntaxWrapper((CSharpSyntaxNode)node); + } + public static implicit operator CSharpSyntaxNode(ConstantPatternSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationExpressionSyntaxWrapper.g.cs index d410f792a7..197e86df2c 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationExpressionSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private DeclarationExpressionSyntaxWrapper(ExpressionSyntax node) } public ExpressionSyntax SyntaxNode => this.node; + public static explicit operator DeclarationExpressionSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new DeclarationExpressionSyntaxWrapper((ExpressionSyntax)node); + } + public static implicit operator ExpressionSyntax(DeclarationExpressionSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationPatternSyntaxWrapper.g.cs index 4b102a1fcb..8fc39fa840 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationPatternSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private DeclarationPatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static explicit operator DeclarationPatternSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new DeclarationPatternSyntaxWrapper((CSharpSyntaxNode)node); + } + public static implicit operator CSharpSyntaxNode(DeclarationPatternSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DefaultConstraintSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DefaultConstraintSyntaxWrapper.g.cs index 3dcb51c10e..315c46cea4 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DefaultConstraintSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DefaultConstraintSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private DefaultConstraintSyntaxWrapper(TypeParameterConstraintSyntax node) } public TypeParameterConstraintSyntax SyntaxNode => this.node; + public static explicit operator DefaultConstraintSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new DefaultConstraintSyntaxWrapper((TypeParameterConstraintSyntax)node); + } + public static implicit operator TypeParameterConstraintSyntax(DefaultConstraintSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardDesignationSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardDesignationSyntaxWrapper.g.cs index 2e6acf8a93..9e6c4e3e7a 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardDesignationSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardDesignationSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private DiscardDesignationSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static explicit operator DiscardDesignationSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new DiscardDesignationSyntaxWrapper((CSharpSyntaxNode)node); + } + public static implicit operator CSharpSyntaxNode(DiscardDesignationSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardPatternSyntaxWrapper.g.cs index 8133cd951a..a53f9a68d3 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardPatternSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private DiscardPatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static explicit operator DiscardPatternSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new DiscardPatternSyntaxWrapper((CSharpSyntaxNode)node); + } + public static implicit operator CSharpSyntaxNode(DiscardPatternSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ExpressionOrPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ExpressionOrPatternSyntaxWrapper.g.cs index e1817bf394..6d697acf92 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ExpressionOrPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ExpressionOrPatternSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private ExpressionOrPatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static explicit operator ExpressionOrPatternSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new ExpressionOrPatternSyntaxWrapper((CSharpSyntaxNode)node); + } + public static implicit operator CSharpSyntaxNode(ExpressionOrPatternSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ForEachVariableStatementSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ForEachVariableStatementSyntaxWrapper.g.cs index b9ae77caae..267a5e3268 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ForEachVariableStatementSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ForEachVariableStatementSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private ForEachVariableStatementSyntaxWrapper(StatementSyntax node) } public StatementSyntax SyntaxNode => this.node; + public static explicit operator ForEachVariableStatementSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new ForEachVariableStatementSyntaxWrapper((StatementSyntax)node); + } + public static implicit operator StatementSyntax(ForEachVariableStatementSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerCallingConventionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerCallingConventionSyntaxWrapper.g.cs index 19068c3711..b1eb2feabf 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerCallingConventionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerCallingConventionSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private FunctionPointerCallingConventionSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static explicit operator FunctionPointerCallingConventionSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new FunctionPointerCallingConventionSyntaxWrapper((CSharpSyntaxNode)node); + } + public static implicit operator CSharpSyntaxNode(FunctionPointerCallingConventionSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterListSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterListSyntaxWrapper.g.cs index 38de4af132..bb2409c892 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterListSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterListSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private FunctionPointerParameterListSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static explicit operator FunctionPointerParameterListSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new FunctionPointerParameterListSyntaxWrapper((CSharpSyntaxNode)node); + } + public static implicit operator CSharpSyntaxNode(FunctionPointerParameterListSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterSyntaxWrapper.g.cs index 96998e6ec0..03a12af036 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private FunctionPointerParameterSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static explicit operator FunctionPointerParameterSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new FunctionPointerParameterSyntaxWrapper((CSharpSyntaxNode)node); + } + public static implicit operator CSharpSyntaxNode(FunctionPointerParameterSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerTypeSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerTypeSyntaxWrapper.g.cs index 33df126323..428951982f 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerTypeSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerTypeSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private FunctionPointerTypeSyntaxWrapper(TypeSyntax node) } public TypeSyntax SyntaxNode => this.node; + public static explicit operator FunctionPointerTypeSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new FunctionPointerTypeSyntaxWrapper((TypeSyntax)node); + } + public static implicit operator TypeSyntax(FunctionPointerTypeSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionListSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionListSyntaxWrapper.g.cs index f77e0c1cae..72eea55811 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionListSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionListSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private FunctionPointerUnmanagedCallingConventionListSyntaxWrapper(CSharpSyntaxN } public CSharpSyntaxNode SyntaxNode => this.node; + public static explicit operator FunctionPointerUnmanagedCallingConventionListSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new FunctionPointerUnmanagedCallingConventionListSyntaxWrapper((CSharpSyntaxNode)node); + } + public static implicit operator CSharpSyntaxNode(FunctionPointerUnmanagedCallingConventionListSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionSyntaxWrapper.g.cs index 75bbbd4a7a..fb048aed9a 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private FunctionPointerUnmanagedCallingConventionSyntaxWrapper(CSharpSyntaxNode } public CSharpSyntaxNode SyntaxNode => this.node; + public static explicit operator FunctionPointerUnmanagedCallingConventionSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new FunctionPointerUnmanagedCallingConventionSyntaxWrapper((CSharpSyntaxNode)node); + } + public static implicit operator CSharpSyntaxNode(FunctionPointerUnmanagedCallingConventionSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitObjectCreationExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitObjectCreationExpressionSyntaxWrapper.g.cs index 9accbfccfe..263e5aa999 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitObjectCreationExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitObjectCreationExpressionSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private ImplicitObjectCreationExpressionSyntaxWrapper(ExpressionSyntax node) } public ExpressionSyntax SyntaxNode => this.node; + public static explicit operator ImplicitObjectCreationExpressionSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new ImplicitObjectCreationExpressionSyntaxWrapper((ExpressionSyntax)node); + } + public static implicit operator ExpressionSyntax(ImplicitObjectCreationExpressionSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.g.cs index 2c19326258..77ae08c74c 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private ImplicitStackAllocArrayCreationExpressionSyntaxWrapper(ExpressionSyntax } public ExpressionSyntax SyntaxNode => this.node; + public static explicit operator ImplicitStackAllocArrayCreationExpressionSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new ImplicitStackAllocArrayCreationExpressionSyntaxWrapper((ExpressionSyntax)node); + } + public static implicit operator ExpressionSyntax(ImplicitStackAllocArrayCreationExpressionSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/IsPatternExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/IsPatternExpressionSyntaxWrapper.g.cs index 5c3b412295..305a0bfd47 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/IsPatternExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/IsPatternExpressionSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private IsPatternExpressionSyntaxWrapper(ExpressionSyntax node) } public ExpressionSyntax SyntaxNode => this.node; + public static explicit operator IsPatternExpressionSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new IsPatternExpressionSyntaxWrapper((ExpressionSyntax)node); + } + public static implicit operator ExpressionSyntax(IsPatternExpressionSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/LocalFunctionStatementSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/LocalFunctionStatementSyntaxWrapper.g.cs index 89ecf1fbf6..bfd916f669 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/LocalFunctionStatementSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/LocalFunctionStatementSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private LocalFunctionStatementSyntaxWrapper(StatementSyntax node) } public StatementSyntax SyntaxNode => this.node; + public static explicit operator LocalFunctionStatementSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new LocalFunctionStatementSyntaxWrapper((StatementSyntax)node); + } + public static implicit operator StatementSyntax(LocalFunctionStatementSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/NullableDirectiveTriviaSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/NullableDirectiveTriviaSyntaxWrapper.g.cs index c824cb27bc..a1591757e5 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/NullableDirectiveTriviaSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/NullableDirectiveTriviaSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private NullableDirectiveTriviaSyntaxWrapper(DirectiveTriviaSyntax node) } public DirectiveTriviaSyntax SyntaxNode => this.node; + public static explicit operator NullableDirectiveTriviaSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new NullableDirectiveTriviaSyntaxWrapper((DirectiveTriviaSyntax)node); + } + public static implicit operator DirectiveTriviaSyntax(NullableDirectiveTriviaSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedPatternSyntaxWrapper.g.cs index 20391449e6..5c809e7bab 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedPatternSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private ParenthesizedPatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static explicit operator ParenthesizedPatternSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new ParenthesizedPatternSyntaxWrapper((CSharpSyntaxNode)node); + } + public static implicit operator CSharpSyntaxNode(ParenthesizedPatternSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedVariableDesignationSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedVariableDesignationSyntaxWrapper.g.cs index a7135cc680..c717e54f62 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedVariableDesignationSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedVariableDesignationSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private ParenthesizedVariableDesignationSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static explicit operator ParenthesizedVariableDesignationSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new ParenthesizedVariableDesignationSyntaxWrapper((CSharpSyntaxNode)node); + } + public static implicit operator CSharpSyntaxNode(ParenthesizedVariableDesignationSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PatternSyntaxWrapper.g.cs index f7c71d9c64..df8b011e0c 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PatternSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private PatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static explicit operator PatternSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new PatternSyntaxWrapper((CSharpSyntaxNode)node); + } + public static implicit operator CSharpSyntaxNode(PatternSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PositionalPatternClauseSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PositionalPatternClauseSyntaxWrapper.g.cs index 44bbb16ce0..6a528fdbb2 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PositionalPatternClauseSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PositionalPatternClauseSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private PositionalPatternClauseSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static explicit operator PositionalPatternClauseSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new PositionalPatternClauseSyntaxWrapper((CSharpSyntaxNode)node); + } + public static implicit operator CSharpSyntaxNode(PositionalPatternClauseSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PrimaryConstructorBaseTypeSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PrimaryConstructorBaseTypeSyntaxWrapper.g.cs index 47c9a6c95c..b3274c8a35 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PrimaryConstructorBaseTypeSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PrimaryConstructorBaseTypeSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private PrimaryConstructorBaseTypeSyntaxWrapper(BaseTypeSyntax node) } public BaseTypeSyntax SyntaxNode => this.node; + public static explicit operator PrimaryConstructorBaseTypeSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new PrimaryConstructorBaseTypeSyntaxWrapper((BaseTypeSyntax)node); + } + public static implicit operator BaseTypeSyntax(PrimaryConstructorBaseTypeSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PropertyPatternClauseSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PropertyPatternClauseSyntaxWrapper.g.cs index a103d0819e..e735c6d0b8 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PropertyPatternClauseSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PropertyPatternClauseSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private PropertyPatternClauseSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static explicit operator PropertyPatternClauseSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new PropertyPatternClauseSyntaxWrapper((CSharpSyntaxNode)node); + } + public static implicit operator CSharpSyntaxNode(PropertyPatternClauseSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RangeExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RangeExpressionSyntaxWrapper.g.cs index 20a5b4bc9e..a650eb5fb7 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RangeExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RangeExpressionSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private RangeExpressionSyntaxWrapper(ExpressionSyntax node) } public ExpressionSyntax SyntaxNode => this.node; + public static explicit operator RangeExpressionSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new RangeExpressionSyntaxWrapper((ExpressionSyntax)node); + } + public static implicit operator ExpressionSyntax(RangeExpressionSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecordDeclarationSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecordDeclarationSyntaxWrapper.g.cs index 5f32f5c547..3a5fca6b42 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecordDeclarationSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecordDeclarationSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private RecordDeclarationSyntaxWrapper(TypeDeclarationSyntax node) } public TypeDeclarationSyntax SyntaxNode => this.node; + public static explicit operator RecordDeclarationSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new RecordDeclarationSyntaxWrapper((TypeDeclarationSyntax)node); + } + public static implicit operator TypeDeclarationSyntax(RecordDeclarationSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecursivePatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecursivePatternSyntaxWrapper.g.cs index 2a041abe0f..c976a52c92 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecursivePatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecursivePatternSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private RecursivePatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static explicit operator RecursivePatternSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new RecursivePatternSyntaxWrapper((CSharpSyntaxNode)node); + } + public static implicit operator CSharpSyntaxNode(RecursivePatternSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefExpressionSyntaxWrapper.g.cs index 7bf10e2df5..8876ba600b 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefExpressionSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private RefExpressionSyntaxWrapper(ExpressionSyntax node) } public ExpressionSyntax SyntaxNode => this.node; + public static explicit operator RefExpressionSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new RefExpressionSyntaxWrapper((ExpressionSyntax)node); + } + public static implicit operator ExpressionSyntax(RefExpressionSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefTypeSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefTypeSyntaxWrapper.g.cs index 6042b038e3..3875b5831b 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefTypeSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefTypeSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private RefTypeSyntaxWrapper(TypeSyntax node) } public TypeSyntax SyntaxNode => this.node; + public static explicit operator RefTypeSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new RefTypeSyntaxWrapper((TypeSyntax)node); + } + public static implicit operator TypeSyntax(RefTypeSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RelationalPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RelationalPatternSyntaxWrapper.g.cs index b3f953a107..30b38b6040 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RelationalPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RelationalPatternSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private RelationalPatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static explicit operator RelationalPatternSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new RelationalPatternSyntaxWrapper((CSharpSyntaxNode)node); + } + public static implicit operator CSharpSyntaxNode(RelationalPatternSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SingleVariableDesignationSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SingleVariableDesignationSyntaxWrapper.g.cs index 7d5a4e27b8..928e550450 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SingleVariableDesignationSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SingleVariableDesignationSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private SingleVariableDesignationSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static explicit operator SingleVariableDesignationSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new SingleVariableDesignationSyntaxWrapper((CSharpSyntaxNode)node); + } + public static implicit operator CSharpSyntaxNode(SingleVariableDesignationSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SubpatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SubpatternSyntaxWrapper.g.cs index bc4e6a7397..4f7354e1c4 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SubpatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SubpatternSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private SubpatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static explicit operator SubpatternSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new SubpatternSyntaxWrapper((CSharpSyntaxNode)node); + } + public static implicit operator CSharpSyntaxNode(SubpatternSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionArmSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionArmSyntaxWrapper.g.cs index 9f63a4821c..fd33975995 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionArmSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionArmSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private SwitchExpressionArmSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static explicit operator SwitchExpressionArmSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new SwitchExpressionArmSyntaxWrapper((CSharpSyntaxNode)node); + } + public static implicit operator CSharpSyntaxNode(SwitchExpressionArmSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionSyntaxWrapper.g.cs index 65fe896fd2..103d9ba983 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private SwitchExpressionSyntaxWrapper(ExpressionSyntax node) } public ExpressionSyntax SyntaxNode => this.node; + public static explicit operator SwitchExpressionSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new SwitchExpressionSyntaxWrapper((ExpressionSyntax)node); + } + public static implicit operator ExpressionSyntax(SwitchExpressionSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ThrowExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ThrowExpressionSyntaxWrapper.g.cs index 8acb7bf499..239f658b0a 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ThrowExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ThrowExpressionSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private ThrowExpressionSyntaxWrapper(ExpressionSyntax node) } public ExpressionSyntax SyntaxNode => this.node; + public static explicit operator ThrowExpressionSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new ThrowExpressionSyntaxWrapper((ExpressionSyntax)node); + } + public static implicit operator ExpressionSyntax(ThrowExpressionSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleElementSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleElementSyntaxWrapper.g.cs index 17eede1f1a..4d693ab107 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleElementSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleElementSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private TupleElementSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static explicit operator TupleElementSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new TupleElementSyntaxWrapper((CSharpSyntaxNode)node); + } + public static implicit operator CSharpSyntaxNode(TupleElementSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleExpressionSyntaxWrapper.g.cs index 0f2671d496..3ccbf7f1f5 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleExpressionSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private TupleExpressionSyntaxWrapper(ExpressionSyntax node) } public ExpressionSyntax SyntaxNode => this.node; + public static explicit operator TupleExpressionSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new TupleExpressionSyntaxWrapper((ExpressionSyntax)node); + } + public static implicit operator ExpressionSyntax(TupleExpressionSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleTypeSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleTypeSyntaxWrapper.g.cs index e3c1616796..ea2c8f6dc0 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleTypeSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleTypeSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private TupleTypeSyntaxWrapper(TypeSyntax node) } public TypeSyntax SyntaxNode => this.node; + public static explicit operator TupleTypeSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new TupleTypeSyntaxWrapper((TypeSyntax)node); + } + public static implicit operator TypeSyntax(TupleTypeSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TypePatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TypePatternSyntaxWrapper.g.cs index 2494964c81..05ba8ae5de 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TypePatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TypePatternSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private TypePatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static explicit operator TypePatternSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new TypePatternSyntaxWrapper((CSharpSyntaxNode)node); + } + public static implicit operator CSharpSyntaxNode(TypePatternSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/UnaryPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/UnaryPatternSyntaxWrapper.g.cs index 1251568414..6da9ab7e92 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/UnaryPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/UnaryPatternSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private UnaryPatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static explicit operator UnaryPatternSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new UnaryPatternSyntaxWrapper((CSharpSyntaxNode)node); + } + public static implicit operator CSharpSyntaxNode(UnaryPatternSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VarPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VarPatternSyntaxWrapper.g.cs index 2c30a988e0..eb34d1a3a7 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VarPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VarPatternSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private VarPatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static explicit operator VarPatternSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new VarPatternSyntaxWrapper((CSharpSyntaxNode)node); + } + public static implicit operator CSharpSyntaxNode(VarPatternSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VariableDesignationSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VariableDesignationSyntaxWrapper.g.cs index a761ee0068..f325ae5f2c 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VariableDesignationSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VariableDesignationSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private VariableDesignationSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static explicit operator VariableDesignationSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new VariableDesignationSyntaxWrapper((CSharpSyntaxNode)node); + } + public static implicit operator CSharpSyntaxNode(VariableDesignationSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WhenClauseSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WhenClauseSyntaxWrapper.g.cs index aa4eb55e99..df1a4c144d 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WhenClauseSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WhenClauseSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private WhenClauseSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static explicit operator WhenClauseSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new WhenClauseSyntaxWrapper((CSharpSyntaxNode)node); + } + public static implicit operator CSharpSyntaxNode(WhenClauseSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WithExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WithExpressionSyntaxWrapper.g.cs index 52f6d385ee..35fbcfb5a1 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WithExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WithExpressionSyntaxWrapper.g.cs @@ -20,6 +20,21 @@ private WithExpressionSyntaxWrapper(ExpressionSyntax node) } public ExpressionSyntax SyntaxNode => this.node; + public static explicit operator WithExpressionSyntaxWrapper(SyntaxNode node) + { + if (node == null) + { + return default; + } + + if (!IsInstance(node)) + { + throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); + } + + return new WithExpressionSyntaxWrapper((ExpressionSyntax)node); + } + public static implicit operator ExpressionSyntax(WithExpressionSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CasePatternSwitchLabelSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CasePatternSwitchLabelSyntaxWrapper.cs index 1d7c918033..a96ee1149f 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CasePatternSwitchLabelSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CasePatternSwitchLabelSyntaxWrapper.cs @@ -44,21 +44,6 @@ public WhenClauseSyntaxWrapper WhenClause } } - public static explicit operator CasePatternSwitchLabelSyntaxWrapper(SyntaxNode node) - { - if (node == null) - { - return default; - } - - if (!IsInstance(node)) - { - throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); - } - - return new CasePatternSwitchLabelSyntaxWrapper((SwitchLabelSyntax)node); - } - public CasePatternSwitchLabelSyntaxWrapper WithKeyword(SyntaxToken keyword) { return new CasePatternSwitchLabelSyntaxWrapper(WithKeywordAccessor(this.SyntaxNode, keyword)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CommonForEachStatementSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CommonForEachStatementSyntaxWrapper.cs index c9c5bd8f83..0e39797f76 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CommonForEachStatementSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CommonForEachStatementSyntaxWrapper.cs @@ -108,21 +108,6 @@ public static implicit operator CommonForEachStatementSyntaxWrapper(ForEachState return new CommonForEachStatementSyntaxWrapper(node); } - public static explicit operator CommonForEachStatementSyntaxWrapper(SyntaxNode node) - { - if (node == null) - { - return default; - } - - if (!IsInstance(node)) - { - throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); - } - - return new CommonForEachStatementSyntaxWrapper((StatementSyntax)node); - } - public CommonForEachStatementSyntaxWrapper WithAwaitKeyword(SyntaxToken awaitKeyword) { return new CommonForEachStatementSyntaxWrapper(WithAwaitKeywordAccessor(this.SyntaxNode, awaitKeyword)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ConstantPatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ConstantPatternSyntaxWrapper.cs index 9ab56b97c9..de5e6fc9ea 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ConstantPatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ConstantPatternSyntaxWrapper.cs @@ -33,21 +33,6 @@ public static explicit operator ConstantPatternSyntaxWrapper(PatternSyntaxWrappe return (ConstantPatternSyntaxWrapper)node.SyntaxNode; } - public static explicit operator ConstantPatternSyntaxWrapper(SyntaxNode node) - { - if (node == null) - { - return default; - } - - if (!IsInstance(node)) - { - throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); - } - - return new ConstantPatternSyntaxWrapper((CSharpSyntaxNode)node); - } - public static implicit operator PatternSyntaxWrapper(ConstantPatternSyntaxWrapper wrapper) { return PatternSyntaxWrapper.FromUpcast(wrapper.node); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationExpressionSyntaxWrapper.cs index 7c617574de..76f2937472 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationExpressionSyntaxWrapper.cs @@ -40,21 +40,6 @@ public VariableDesignationSyntaxWrapper Designation } } - public static explicit operator DeclarationExpressionSyntaxWrapper(SyntaxNode node) - { - if (node == null) - { - return default; - } - - if (!IsInstance(node)) - { - throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); - } - - return new DeclarationExpressionSyntaxWrapper((ExpressionSyntax)node); - } - public DeclarationExpressionSyntaxWrapper WithType(TypeSyntax type) { return new DeclarationExpressionSyntaxWrapper(WithTypeAccessor(this.SyntaxNode, type)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationPatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationPatternSyntaxWrapper.cs index 0f4fa4ce85..f08697fcd3 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationPatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationPatternSyntaxWrapper.cs @@ -45,21 +45,6 @@ public static explicit operator DeclarationPatternSyntaxWrapper(PatternSyntaxWra return (DeclarationPatternSyntaxWrapper)node.SyntaxNode; } - public static explicit operator DeclarationPatternSyntaxWrapper(SyntaxNode node) - { - if (node == null) - { - return default; - } - - if (!IsInstance(node)) - { - throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); - } - - return new DeclarationPatternSyntaxWrapper((CSharpSyntaxNode)node); - } - public static implicit operator PatternSyntaxWrapper(DeclarationPatternSyntaxWrapper wrapper) { return PatternSyntaxWrapper.FromUpcast(wrapper.node); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardDesignationSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardDesignationSyntaxWrapper.cs index aa7ef4add4..2d51ff1be7 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardDesignationSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardDesignationSyntaxWrapper.cs @@ -32,21 +32,6 @@ public static explicit operator DiscardDesignationSyntaxWrapper(VariableDesignat return (DiscardDesignationSyntaxWrapper)node.SyntaxNode; } - public static explicit operator DiscardDesignationSyntaxWrapper(SyntaxNode node) - { - if (node == null) - { - return default; - } - - if (!IsInstance(node)) - { - throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); - } - - return new DiscardDesignationSyntaxWrapper((CSharpSyntaxNode)node); - } - public static implicit operator VariableDesignationSyntaxWrapper(DiscardDesignationSyntaxWrapper wrapper) { return VariableDesignationSyntaxWrapper.FromUpcast(wrapper.node); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardPatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardPatternSyntaxWrapper.cs index 9435f84b91..7d8e9ec910 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardPatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardPatternSyntaxWrapper.cs @@ -32,21 +32,6 @@ public static explicit operator DiscardPatternSyntaxWrapper(PatternSyntaxWrapper return (DiscardPatternSyntaxWrapper)node.SyntaxNode; } - public static explicit operator DiscardPatternSyntaxWrapper(SyntaxNode node) - { - if (node == null) - { - return default; - } - - if (!IsInstance(node)) - { - throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); - } - - return new DiscardPatternSyntaxWrapper((CSharpSyntaxNode)node); - } - public static implicit operator PatternSyntaxWrapper(DiscardPatternSyntaxWrapper wrapper) { return PatternSyntaxWrapper.FromUpcast(wrapper.node); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ForEachVariableStatementSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ForEachVariableStatementSyntaxWrapper.cs index 2bc572bcec..5326051a26 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ForEachVariableStatementSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ForEachVariableStatementSyntaxWrapper.cs @@ -104,21 +104,6 @@ public static explicit operator ForEachVariableStatementSyntaxWrapper(CommonForE return (ForEachVariableStatementSyntaxWrapper)node.SyntaxNode; } - public static explicit operator ForEachVariableStatementSyntaxWrapper(SyntaxNode node) - { - if (node == null) - { - return default; - } - - if (!IsInstance(node)) - { - throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); - } - - return new ForEachVariableStatementSyntaxWrapper((StatementSyntax)node); - } - public static implicit operator CommonForEachStatementSyntaxWrapper(ForEachVariableStatementSyntaxWrapper wrapper) { return CommonForEachStatementSyntaxWrapper.FromUpcast(wrapper.node); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.cs index 2eaafa45c1..842022e0dc 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.cs @@ -63,21 +63,6 @@ public InitializerExpressionSyntax Initializer } } - public static explicit operator ImplicitStackAllocArrayCreationExpressionSyntaxWrapper(SyntaxNode node) - { - if (node == null) - { - return default; - } - - if (!IsInstance(node)) - { - throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); - } - - return new ImplicitStackAllocArrayCreationExpressionSyntaxWrapper((ExpressionSyntax)node); - } - public ImplicitStackAllocArrayCreationExpressionSyntaxWrapper WithStackAllocKeyword(SyntaxToken stackAllocKeyword) { return new ImplicitStackAllocArrayCreationExpressionSyntaxWrapper(WithStackAllocKeywordAccessor(this.SyntaxNode, stackAllocKeyword)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/IsPatternExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/IsPatternExpressionSyntaxWrapper.cs index 150e63e3a4..91a5046d54 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/IsPatternExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/IsPatternExpressionSyntaxWrapper.cs @@ -52,21 +52,6 @@ public PatternSyntaxWrapper Pattern } } - public static explicit operator IsPatternExpressionSyntaxWrapper(SyntaxNode node) - { - if (node == null) - { - return default; - } - - if (!IsInstance(node)) - { - throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); - } - - return new IsPatternExpressionSyntaxWrapper((ExpressionSyntax)node); - } - public IsPatternExpressionSyntaxWrapper WithExpression(ExpressionSyntax expression) { return new IsPatternExpressionSyntaxWrapper(WithExpressionAccessor(this.SyntaxNode, expression)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/LocalFunctionStatementSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/LocalFunctionStatementSyntaxWrapper.cs index 1f6681af58..f4d1122d7e 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/LocalFunctionStatementSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/LocalFunctionStatementSyntaxWrapper.cs @@ -124,21 +124,6 @@ public SyntaxToken SemicolonToken } } - public static explicit operator LocalFunctionStatementSyntaxWrapper(SyntaxNode node) - { - if (node == null) - { - return default; - } - - if (!IsInstance(node)) - { - throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); - } - - return new LocalFunctionStatementSyntaxWrapper((StatementSyntax)node); - } - public LocalFunctionStatementSyntaxWrapper WithModifiers(SyntaxTokenList modifiers) { return new LocalFunctionStatementSyntaxWrapper(WithModifiersAccessor(this.SyntaxNode, modifiers)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ParenthesizedVariableDesignationSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ParenthesizedVariableDesignationSyntaxWrapper.cs index 164b4bf994..130cf7c16b 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ParenthesizedVariableDesignationSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ParenthesizedVariableDesignationSyntaxWrapper.cs @@ -56,21 +56,6 @@ public static explicit operator ParenthesizedVariableDesignationSyntaxWrapper(Va return (ParenthesizedVariableDesignationSyntaxWrapper)node.SyntaxNode; } - public static explicit operator ParenthesizedVariableDesignationSyntaxWrapper(SyntaxNode node) - { - if (node == null) - { - return default; - } - - if (!IsInstance(node)) - { - throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); - } - - return new ParenthesizedVariableDesignationSyntaxWrapper((CSharpSyntaxNode)node); - } - public static implicit operator VariableDesignationSyntaxWrapper(ParenthesizedVariableDesignationSyntaxWrapper wrapper) { return VariableDesignationSyntaxWrapper.FromUpcast(wrapper.node); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PatternSyntaxWrapper.cs index 155965d07a..b64b1db9c6 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PatternSyntaxWrapper.cs @@ -14,21 +14,6 @@ static PatternSyntaxWrapper() WrappedType = WrapperHelper.GetWrappedType(typeof(PatternSyntaxWrapper)); } - public static explicit operator PatternSyntaxWrapper(SyntaxNode node) - { - if (node == null) - { - return default; - } - - if (!IsInstance(node)) - { - throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); - } - - return new PatternSyntaxWrapper((CSharpSyntaxNode)node); - } - internal static PatternSyntaxWrapper FromUpcast(CSharpSyntaxNode node) { return new PatternSyntaxWrapper(node); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PositionalPatternClauseSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PositionalPatternClauseSyntaxWrapper.cs index 5cb5f1b5af..f212da6bf1 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PositionalPatternClauseSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PositionalPatternClauseSyntaxWrapper.cs @@ -53,21 +53,6 @@ public SyntaxToken CloseParenToken } } - public static explicit operator PositionalPatternClauseSyntaxWrapper(SyntaxNode node) - { - if (node == null) - { - return default; - } - - if (!IsInstance(node)) - { - throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); - } - - return new PositionalPatternClauseSyntaxWrapper((CSharpSyntaxNode)node); - } - public PositionalPatternClauseSyntaxWrapper AddSubpatterns(params SubpatternSyntaxWrapper[] items) { return new PositionalPatternClauseSyntaxWrapper(this.WithSubpatterns(this.Subpatterns.AddRange(items))); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PropertyPatternClauseSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PropertyPatternClauseSyntaxWrapper.cs index fd601b1c43..4c30278054 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PropertyPatternClauseSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PropertyPatternClauseSyntaxWrapper.cs @@ -53,21 +53,6 @@ public SyntaxToken CloseBraceToken } } - public static explicit operator PropertyPatternClauseSyntaxWrapper(SyntaxNode node) - { - if (node == null) - { - return default; - } - - if (!IsInstance(node)) - { - throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); - } - - return new PropertyPatternClauseSyntaxWrapper((CSharpSyntaxNode)node); - } - public PropertyPatternClauseSyntaxWrapper AddSubpatterns(params SubpatternSyntaxWrapper[] items) { return new PropertyPatternClauseSyntaxWrapper(this.WithSubpatterns(this.Subpatterns.AddRange(items))); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RangeExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RangeExpressionSyntaxWrapper.cs index 1998409a17..2f06de449a 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RangeExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RangeExpressionSyntaxWrapper.cs @@ -53,21 +53,6 @@ public ExpressionSyntax RightOperand } } - public static explicit operator RangeExpressionSyntaxWrapper(ExpressionSyntax node) - { - if (node == null) - { - return default; - } - - if (!IsInstance(node)) - { - throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); - } - - return new RangeExpressionSyntaxWrapper((ExpressionSyntax)node); - } - public RangeExpressionSyntaxWrapper WithLeftOperand(ExpressionSyntax leftOperand) { return new RangeExpressionSyntaxWrapper(WithLeftOperandAccessor(this.SyntaxNode, leftOperand)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RecursivePatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RecursivePatternSyntaxWrapper.cs index 712bf0d264..6e0749a4d5 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RecursivePatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RecursivePatternSyntaxWrapper.cs @@ -71,21 +71,6 @@ public static explicit operator RecursivePatternSyntaxWrapper(PatternSyntaxWrapp return (RecursivePatternSyntaxWrapper)node.SyntaxNode; } - public static explicit operator RecursivePatternSyntaxWrapper(SyntaxNode node) - { - if (node == null) - { - return default; - } - - if (!IsInstance(node)) - { - throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); - } - - return new RecursivePatternSyntaxWrapper((CSharpSyntaxNode)node); - } - public static implicit operator PatternSyntaxWrapper(RecursivePatternSyntaxWrapper wrapper) { return PatternSyntaxWrapper.FromUpcast(wrapper.node); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefExpressionSyntaxWrapper.cs index 0c39c5e4c7..2938476e52 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefExpressionSyntaxWrapper.cs @@ -39,21 +39,6 @@ public ExpressionSyntax Expression } } - public static explicit operator RefExpressionSyntaxWrapper(SyntaxNode node) - { - if (node == null) - { - return default; - } - - if (!IsInstance(node)) - { - throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); - } - - return new RefExpressionSyntaxWrapper((ExpressionSyntax)node); - } - public RefExpressionSyntaxWrapper WithRefKeyword(SyntaxToken refKeyword) { return new RefExpressionSyntaxWrapper(WithRefKeywordAccessor(this.SyntaxNode, refKeyword)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefTypeSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefTypeSyntaxWrapper.cs index 9dd46e8e68..79bbd046e9 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefTypeSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefTypeSyntaxWrapper.cs @@ -51,21 +51,6 @@ public TypeSyntax Type } } - public static explicit operator RefTypeSyntaxWrapper(SyntaxNode node) - { - if (node == null) - { - return default; - } - - if (!IsInstance(node)) - { - throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); - } - - return new RefTypeSyntaxWrapper((TypeSyntax)node); - } - public RefTypeSyntaxWrapper WithRefKeyword(SyntaxToken refKeyword) { return new RefTypeSyntaxWrapper(WithRefKeywordAccessor(this.SyntaxNode, refKeyword)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SingleVariableDesignationSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SingleVariableDesignationSyntaxWrapper.cs index 5f51a593f6..e2051938e6 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SingleVariableDesignationSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SingleVariableDesignationSyntaxWrapper.cs @@ -32,21 +32,6 @@ public static explicit operator SingleVariableDesignationSyntaxWrapper(VariableD return (SingleVariableDesignationSyntaxWrapper)node.SyntaxNode; } - public static explicit operator SingleVariableDesignationSyntaxWrapper(SyntaxNode node) - { - if (node == null) - { - return default; - } - - if (!IsInstance(node)) - { - throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); - } - - return new SingleVariableDesignationSyntaxWrapper((CSharpSyntaxNode)node); - } - public static implicit operator VariableDesignationSyntaxWrapper(SingleVariableDesignationSyntaxWrapper wrapper) { return VariableDesignationSyntaxWrapper.FromUpcast(wrapper.node); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SubpatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SubpatternSyntaxWrapper.cs index fbb86e5ca4..0575db41ec 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SubpatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SubpatternSyntaxWrapper.cs @@ -42,21 +42,6 @@ public PatternSyntaxWrapper Pattern } } - public static explicit operator SubpatternSyntaxWrapper(SyntaxNode node) - { - if (node == null) - { - return default; - } - - if (!IsInstance(node)) - { - throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); - } - - return new SubpatternSyntaxWrapper((CSharpSyntaxNode)node); - } - public SubpatternSyntaxWrapper WithNameColon(NameColonSyntax nameColon) { return new SubpatternSyntaxWrapper(WithNameColonAccessor(this.SyntaxNode, nameColon)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionArmSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionArmSyntaxWrapper.cs index 710e50a4d0..7d3527df21 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionArmSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionArmSyntaxWrapper.cs @@ -66,21 +66,6 @@ public SyntaxToken EqualsGreaterThanToken } } - public static explicit operator SwitchExpressionArmSyntaxWrapper(SyntaxNode node) - { - if (node == null) - { - return default; - } - - if (!IsInstance(node)) - { - throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); - } - - return new SwitchExpressionArmSyntaxWrapper((CSharpSyntaxNode)node); - } - public SwitchExpressionArmSyntaxWrapper WithPattern(PatternSyntaxWrapper pattern) { return new SwitchExpressionArmSyntaxWrapper(WithPatternAccessor(this.SyntaxNode, pattern.SyntaxNode)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionSyntaxWrapper.cs index 7bb0d40f3f..45f715f53c 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionSyntaxWrapper.cs @@ -77,21 +77,6 @@ public SyntaxToken CloseBraceToken } } - public static explicit operator SwitchExpressionSyntaxWrapper(SyntaxNode node) - { - if (node == null) - { - return default; - } - - if (!IsInstance(node)) - { - throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); - } - - return new SwitchExpressionSyntaxWrapper((ExpressionSyntax)node); - } - public SwitchExpressionSyntaxWrapper AddArms(params SwitchExpressionArmSyntaxWrapper[] arms) { return new SwitchExpressionSyntaxWrapper(this.WithArms(this.Arms.AddRange(arms))); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ThrowExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ThrowExpressionSyntaxWrapper.cs index bc43fc0e65..b561cca0d9 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ThrowExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ThrowExpressionSyntaxWrapper.cs @@ -39,21 +39,6 @@ public ExpressionSyntax Expression } } - public static explicit operator ThrowExpressionSyntaxWrapper(SyntaxNode node) - { - if (node == null) - { - return default; - } - - if (!IsInstance(node)) - { - throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); - } - - return new ThrowExpressionSyntaxWrapper((ExpressionSyntax)node); - } - public ThrowExpressionSyntaxWrapper WithThrowKeyword(SyntaxToken throwKeyword) { return new ThrowExpressionSyntaxWrapper(WithThrowKeywordAccessor(this.SyntaxNode, throwKeyword)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleElementSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleElementSyntaxWrapper.cs index 55f64e9a9b..ef0f009120 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleElementSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleElementSyntaxWrapper.cs @@ -40,21 +40,6 @@ public TypeSyntax Type } } - public static explicit operator TupleElementSyntaxWrapper(SyntaxNode node) - { - if (node == null) - { - return default; - } - - if (!IsInstance(node)) - { - throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); - } - - return new TupleElementSyntaxWrapper((CSharpSyntaxNode)node); - } - public TupleElementSyntaxWrapper WithIdentifier(SyntaxToken identifier) { return new TupleElementSyntaxWrapper(WithIdentifierAccessor(this.SyntaxNode, identifier)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleExpressionSyntaxWrapper.cs index 398345c71b..09fd37ff88 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleExpressionSyntaxWrapper.cs @@ -51,21 +51,6 @@ public SyntaxToken CloseParenToken } } - public static explicit operator TupleExpressionSyntaxWrapper(SyntaxNode node) - { - if (node == null) - { - return default; - } - - if (!IsInstance(node)) - { - throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); - } - - return new TupleExpressionSyntaxWrapper((ExpressionSyntax)node); - } - public TupleExpressionSyntaxWrapper AddArguments(params ArgumentSyntax[] items) { return new TupleExpressionSyntaxWrapper(this.WithArguments(this.Arguments.AddRange(items))); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleTypeSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleTypeSyntaxWrapper.cs index a9544f40cf..4f472e424c 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleTypeSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleTypeSyntaxWrapper.cs @@ -51,21 +51,6 @@ public SyntaxToken CloseParenToken } } - public static explicit operator TupleTypeSyntaxWrapper(SyntaxNode node) - { - if (node == null) - { - return default; - } - - if (!IsInstance(node)) - { - throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); - } - - return new TupleTypeSyntaxWrapper((TypeSyntax)node); - } - public TupleTypeSyntaxWrapper AddElements(params TupleElementSyntaxWrapper[] items) { return new TupleTypeSyntaxWrapper(this.WithElements(this.Elements.AddRange(items))); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VarPatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VarPatternSyntaxWrapper.cs index 809a8263ae..4df0c059e4 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VarPatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VarPatternSyntaxWrapper.cs @@ -46,21 +46,6 @@ public static explicit operator VarPatternSyntaxWrapper(PatternSyntaxWrapper nod return (VarPatternSyntaxWrapper)node.SyntaxNode; } - public static explicit operator VarPatternSyntaxWrapper(SyntaxNode node) - { - if (node == null) - { - return default; - } - - if (!IsInstance(node)) - { - throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); - } - - return new VarPatternSyntaxWrapper((CSharpSyntaxNode)node); - } - public static implicit operator PatternSyntaxWrapper(VarPatternSyntaxWrapper wrapper) { return PatternSyntaxWrapper.FromUpcast(wrapper.node); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VariableDesignationSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VariableDesignationSyntaxWrapper.cs index 6c920befea..cbf6adefb7 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VariableDesignationSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VariableDesignationSyntaxWrapper.cs @@ -14,21 +14,6 @@ static VariableDesignationSyntaxWrapper() WrappedType = WrapperHelper.GetWrappedType(typeof(VariableDesignationSyntaxWrapper)); } - public static explicit operator VariableDesignationSyntaxWrapper(SyntaxNode node) - { - if (node == null) - { - return default; - } - - if (!IsInstance(node)) - { - throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); - } - - return new VariableDesignationSyntaxWrapper((CSharpSyntaxNode)node); - } - internal static VariableDesignationSyntaxWrapper FromUpcast(CSharpSyntaxNode node) { return new VariableDesignationSyntaxWrapper(node); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/WhenClauseSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/WhenClauseSyntaxWrapper.cs index 9ebded8746..bd6721d2fd 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/WhenClauseSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/WhenClauseSyntaxWrapper.cs @@ -40,21 +40,6 @@ public ExpressionSyntax Condition } } - public static explicit operator WhenClauseSyntaxWrapper(SyntaxNode node) - { - if (node == null) - { - return default; - } - - if (!IsInstance(node)) - { - throw new InvalidCastException($"Cannot cast '{node.GetType().FullName}' to '{WrappedTypeName}'"); - } - - return new WhenClauseSyntaxWrapper((CSharpSyntaxNode)node); - } - public WhenClauseSyntaxWrapper WithWhenKeyword(SyntaxToken whenKeyword) { return new WhenClauseSyntaxWrapper(WithWhenKeywordAccessor(this.SyntaxNode, whenKeyword)); From 5157250a446d316d3095628a2ec76a56b5c96060 Mon Sep 17 00:00:00 2001 From: Sam Harwell Date: Mon, 16 Nov 2020 20:33:05 -0800 Subject: [PATCH 05/18] Generate SyntaxWrapperHelper --- .../ReadabilityRules/SA1141CodeFixProvider.cs | 2 +- .../SyntaxLightupGenerator.cs | 245 ++++++++++++++++++ .../Lightup/WrapperHelperTests.cs | 2 +- .../SyntaxWrapperHelper.g.cs} | 46 ++-- .../CasePatternSwitchLabelSyntaxWrapper.cs | 2 +- .../CommonForEachStatementSyntaxWrapper.cs | 2 +- .../Lightup/ConstantPatternSyntaxWrapper.cs | 2 +- .../DeclarationExpressionSyntaxWrapper.cs | 2 +- .../DeclarationPatternSyntaxWrapper.cs | 2 +- .../DiscardDesignationSyntaxWrapper.cs | 2 +- .../Lightup/DiscardPatternSyntaxWrapper.cs | 2 +- .../ForEachVariableStatementSyntaxWrapper.cs | 2 +- ...locArrayCreationExpressionSyntaxWrapper.cs | 2 +- .../IsPatternExpressionSyntaxWrapper.cs | 2 +- .../Lightup/LightupHelpers.cs | 2 +- .../LocalFunctionStatementSyntaxWrapper.cs | 2 +- ...hesizedVariableDesignationSyntaxWrapper.cs | 2 +- .../Lightup/PatternSyntaxWrapper.cs | 2 +- .../PositionalPatternClauseSyntaxWrapper.cs | 2 +- .../PropertyPatternClauseSyntaxWrapper.cs | 2 +- .../Lightup/RangeExpressionSyntaxWrapper.cs | 2 +- .../Lightup/RecursivePatternSyntaxWrapper.cs | 2 +- .../Lightup/RefExpressionSyntaxWrapper.cs | 2 +- .../Lightup/RefTypeSyntaxWrapper.cs | 2 +- .../SingleVariableDesignationSyntaxWrapper.cs | 2 +- .../Lightup/SubpatternSyntaxWrapper.cs | 2 +- .../SwitchExpressionArmSyntaxWrapper.cs | 2 +- .../Lightup/SwitchExpressionSyntaxWrapper.cs | 2 +- .../Lightup/SyntaxFactoryEx.cs | 12 +- .../Lightup/ThrowExpressionSyntaxWrapper.cs | 2 +- .../Lightup/TupleElementSyntaxWrapper.cs | 2 +- .../Lightup/TupleExpressionSyntaxWrapper.cs | 2 +- .../Lightup/TupleTypeSyntaxWrapper.cs | 2 +- .../Lightup/VarPatternSyntaxWrapper.cs | 2 +- .../VariableDesignationSyntaxWrapper.cs | 2 +- .../Lightup/WhenClauseSyntaxWrapper.cs | 2 +- 36 files changed, 310 insertions(+), 59 deletions(-) rename StyleCop.Analyzers/StyleCop.Analyzers/Lightup/{WrapperHelper.cs => .generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SyntaxWrapperHelper.g.cs} (61%) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.CodeFixes/ReadabilityRules/SA1141CodeFixProvider.cs b/StyleCop.Analyzers/StyleCop.Analyzers.CodeFixes/ReadabilityRules/SA1141CodeFixProvider.cs index dc01b335c2..b53676c8a8 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers.CodeFixes/ReadabilityRules/SA1141CodeFixProvider.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers.CodeFixes/ReadabilityRules/SA1141CodeFixProvider.cs @@ -104,7 +104,7 @@ private static SyntaxNode GetReplacementNode(SemanticModel semanticModel, Syntax private static SyntaxNode TransformGenericNameToTuple(SemanticModel semanticModel, GenericNameSyntax genericName) { - var implementationType = typeof(SeparatedSyntaxListWrapper<>.AutoWrapSeparatedSyntaxList<>).MakeGenericType(typeof(TupleElementSyntaxWrapper), WrapperHelper.GetWrappedType(typeof(TupleElementSyntaxWrapper))); + var implementationType = typeof(SeparatedSyntaxListWrapper<>.AutoWrapSeparatedSyntaxList<>).MakeGenericType(typeof(TupleElementSyntaxWrapper), SyntaxWrapperHelper.GetWrappedType(typeof(TupleElementSyntaxWrapper))); var tupleElements = (SeparatedSyntaxListWrapper)Activator.CreateInstance(implementationType); foreach (var typeArgument in genericName.TypeArgumentList.Arguments) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs b/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs index d3243ed791..636a933ae6 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs @@ -41,6 +41,7 @@ public void Execute(GeneratorExecutionContext context) var syntaxData = new SyntaxData(in context, XDocument.Parse(syntaxText.ToString())); this.GenerateSyntaxWrappers(in context, syntaxData); + this.GenerateSyntaxWrapperHelper(in context, syntaxData.Nodes); } private void GenerateSyntaxWrappers(in GeneratorExecutionContext context, SyntaxData syntaxData) @@ -311,6 +312,250 @@ private void GenerateSyntaxWrapper(in GeneratorExecutionContext context, SyntaxD context.AddSource(nodeData.WrapperName + ".g.cs", SourceText.From(wrapperNamespace.ToFullString(), Encoding.UTF8)); } + private void GenerateSyntaxWrapperHelper(in GeneratorExecutionContext context, ImmutableArray wrapperTypes) + { + // private static readonly ImmutableDictionary WrappedTypes; + var wrappedTypes = SyntaxFactory.FieldDeclaration( + attributeLists: default, + modifiers: SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PrivateKeyword), SyntaxFactory.Token(SyntaxKind.StaticKeyword), SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword)), + declaration: SyntaxFactory.VariableDeclaration( + type: SyntaxFactory.GenericName( + identifier: SyntaxFactory.Identifier("ImmutableDictionary"), + typeArgumentList: SyntaxFactory.TypeArgumentList( + SyntaxFactory.SeparatedList( + new[] + { + SyntaxFactory.IdentifierName("Type"), + SyntaxFactory.IdentifierName("Type"), + }))), + variables: SyntaxFactory.SingletonSeparatedList(SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier("WrappedTypes"))))); + + // var csharpCodeAnalysisAssembly = typeof(CSharpSyntaxNode).GetTypeInfo().Assembly; + // var builder = ImmutableDictionary.CreateBuilder(); + var staticCtorStatements = SyntaxFactory.List() + .Add(SyntaxFactory.LocalDeclarationStatement(SyntaxFactory.VariableDeclaration( + type: SyntaxFactory.IdentifierName("var"), + variables: SyntaxFactory.SingletonSeparatedList(SyntaxFactory.VariableDeclarator( + identifier: SyntaxFactory.Identifier("csharpCodeAnalysisAssembly"), + argumentList: null, + initializer: SyntaxFactory.EqualsValueClause( + SyntaxFactory.MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + expression: SyntaxFactory.InvocationExpression( + SyntaxFactory.MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + expression: SyntaxFactory.TypeOfExpression(SyntaxFactory.IdentifierName("CSharpSyntaxNode")), + name: SyntaxFactory.IdentifierName("GetTypeInfo"))), + name: SyntaxFactory.IdentifierName("Assembly")))))))) + .Add(SyntaxFactory.LocalDeclarationStatement(SyntaxFactory.VariableDeclaration( + type: SyntaxFactory.IdentifierName("var"), + variables: SyntaxFactory.SingletonSeparatedList(SyntaxFactory.VariableDeclarator( + identifier: SyntaxFactory.Identifier("builder"), + argumentList: null, + initializer: SyntaxFactory.EqualsValueClause( + SyntaxFactory.InvocationExpression( + SyntaxFactory.MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + expression: SyntaxFactory.IdentifierName("ImmutableDictionary"), + name: SyntaxFactory.GenericName( + identifier: SyntaxFactory.Identifier("CreateBuilder"), + typeArgumentList: SyntaxFactory.TypeArgumentList( + SyntaxFactory.SeparatedList( + new[] + { + SyntaxFactory.IdentifierName("Type"), + SyntaxFactory.IdentifierName("Type"), + }))))))))))); + + foreach (var node in wrapperTypes.OrderBy(node => node.Name, StringComparer.OrdinalIgnoreCase)) + { + if (node.WrapperName is null) + { + continue; + } + + if (node.Name == nameof(CommonForEachStatementSyntax)) + { + // Prior to C# 7, ForEachStatementSyntax was the base type for all foreach statements. If + // the CommonForEachStatementSyntax type isn't found at runtime, we fall back to using this type instead. + // + // var forEachStatementSyntaxType = csharpCodeAnalysisAssembly.GetType(CommonForEachStatementSyntaxWrapper.WrappedTypeName) + // ?? csharpCodeAnalysisAssembly.GetType(CommonForEachStatementSyntaxWrapper.FallbackWrappedTypeName); + staticCtorStatements = staticCtorStatements.Add( + SyntaxFactory.LocalDeclarationStatement(SyntaxFactory.VariableDeclaration( + type: SyntaxFactory.IdentifierName("var"), + variables: SyntaxFactory.SingletonSeparatedList(SyntaxFactory.VariableDeclarator( + identifier: SyntaxFactory.Identifier("forEachStatementSyntaxType"), + argumentList: null, + initializer: SyntaxFactory.EqualsValueClause( + SyntaxFactory.BinaryExpression( + SyntaxKind.CoalesceExpression, + left: SyntaxFactory.InvocationExpression( + expression: SyntaxFactory.MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + expression: SyntaxFactory.IdentifierName("csharpCodeAnalysisAssembly"), + name: SyntaxFactory.IdentifierName("GetType")), + argumentList: SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Argument( + SyntaxFactory.MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + expression: SyntaxFactory.IdentifierName(node.WrapperName), + name: SyntaxFactory.IdentifierName("WrappedTypeName")))))), + right: SyntaxFactory.InvocationExpression( + expression: SyntaxFactory.MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + expression: SyntaxFactory.IdentifierName("csharpCodeAnalysisAssembly"), + name: SyntaxFactory.IdentifierName("GetType")), + argumentList: SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Argument( + SyntaxFactory.MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + expression: SyntaxFactory.IdentifierName(node.WrapperName), + name: SyntaxFactory.IdentifierName("FallbackWrappedTypeName"))))))))))))); + + // builder.Add(typeof(CommonForEachStatementSyntaxWrapper), forEachStatementSyntaxType); + staticCtorStatements = staticCtorStatements.Add(SyntaxFactory.ExpressionStatement( + SyntaxFactory.InvocationExpression( + expression: SyntaxFactory.MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + expression: SyntaxFactory.IdentifierName("builder"), + name: SyntaxFactory.IdentifierName("Add")), + argumentList: SyntaxFactory.ArgumentList( + SyntaxFactory.SeparatedList( + new[] + { + SyntaxFactory.Argument(SyntaxFactory.TypeOfExpression(SyntaxFactory.IdentifierName(node.WrapperName))), + SyntaxFactory.Argument(SyntaxFactory.IdentifierName("forEachStatementSyntaxType")), + }))))); + + continue; + } + + // builder.Add(typeof(ConstantPatternSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(ConstantPatternSyntaxWrapper.WrappedTypeName)); + staticCtorStatements = staticCtorStatements.Add(SyntaxFactory.ExpressionStatement( + SyntaxFactory.InvocationExpression( + expression: SyntaxFactory.MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + expression: SyntaxFactory.IdentifierName("builder"), + name: SyntaxFactory.IdentifierName("Add")), + argumentList: SyntaxFactory.ArgumentList( + SyntaxFactory.SeparatedList( + new[] + { + SyntaxFactory.Argument(SyntaxFactory.TypeOfExpression(SyntaxFactory.IdentifierName(node.WrapperName))), + SyntaxFactory.Argument( + SyntaxFactory.InvocationExpression( + expression: SyntaxFactory.MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + expression: SyntaxFactory.IdentifierName("csharpCodeAnalysisAssembly"), + name: SyntaxFactory.IdentifierName("GetType")), + argumentList: SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Argument( + SyntaxFactory.MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + expression: SyntaxFactory.IdentifierName(node.WrapperName), + name: SyntaxFactory.IdentifierName("WrappedTypeName"))))))), + }))))); + } + + // WrappedTypes = builder.ToImmutable(); + staticCtorStatements = staticCtorStatements.Add(SyntaxFactory.ExpressionStatement( + SyntaxFactory.AssignmentExpression( + SyntaxKind.SimpleAssignmentExpression, + left: SyntaxFactory.IdentifierName("WrappedTypes"), + right: SyntaxFactory.InvocationExpression( + SyntaxFactory.MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + expression: SyntaxFactory.IdentifierName("builder"), + name: SyntaxFactory.IdentifierName("ToImmutable")))))); + + var staticCtor = SyntaxFactory.ConstructorDeclaration( + attributeLists: default, + modifiers: SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.StaticKeyword)), + identifier: SyntaxFactory.Identifier("SyntaxWrapperHelper"), + parameterList: SyntaxFactory.ParameterList(), + initializer: null, + body: SyntaxFactory.Block(staticCtorStatements)); + + // internal static Type GetWrappedType(Type wrapperType) + // { + // if (WrappedTypes.TryGetValue(wrapperType, out Type wrappedType)) + // { + // return wrappedType; + // } + // + // return null; + // } + var getWrappedType = SyntaxFactory.MethodDeclaration( + attributeLists: default, + modifiers: SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.InternalKeyword), SyntaxFactory.Token(SyntaxKind.StaticKeyword)), + returnType: SyntaxFactory.IdentifierName("Type"), + explicitInterfaceSpecifier: null, + identifier: SyntaxFactory.Identifier("GetWrappedType"), + typeParameterList: null, + parameterList: SyntaxFactory.ParameterList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Parameter( + attributeLists: default, + modifiers: default, + type: SyntaxFactory.IdentifierName("Type"), + identifier: SyntaxFactory.Identifier("wrapperType"), + @default: null))), + constraintClauses: default, + body: SyntaxFactory.Block( + SyntaxFactory.IfStatement( + condition: SyntaxFactory.InvocationExpression( + expression: SyntaxFactory.MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + expression: SyntaxFactory.IdentifierName("WrappedTypes"), + name: SyntaxFactory.IdentifierName("TryGetValue")), + argumentList: SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList( + new[] + { + SyntaxFactory.Argument(SyntaxFactory.IdentifierName("wrapperType")), + SyntaxFactory.Argument( + nameColon: null, + refKindKeyword: SyntaxFactory.Token(SyntaxKind.OutKeyword), + expression: SyntaxFactory.DeclarationExpression( + type: SyntaxFactory.IdentifierName("Type"), + designation: SyntaxFactory.SingleVariableDesignation(SyntaxFactory.Identifier("wrappedType")))), + }))), + statement: SyntaxFactory.Block( + SyntaxFactory.ReturnStatement(SyntaxFactory.IdentifierName("wrappedType")))), + SyntaxFactory.ReturnStatement(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression))), + expressionBody: null); + + var wrapperHelperClass = SyntaxFactory.ClassDeclaration( + attributeLists: default, + modifiers: SyntaxTokenList.Create(SyntaxFactory.Token(SyntaxKind.InternalKeyword)).Add(SyntaxFactory.Token(SyntaxKind.StaticKeyword)), + identifier: SyntaxFactory.Identifier("SyntaxWrapperHelper"), + typeParameterList: null, + baseList: null, + constraintClauses: default, + members: SyntaxFactory.List() + .Add(wrappedTypes) + .Add(staticCtor) + .Add(getWrappedType)); + var wrapperNamespace = SyntaxFactory.NamespaceDeclaration( + name: SyntaxFactory.ParseName("StyleCop.Analyzers.Lightup"), + externs: default, + usings: SyntaxFactory.List() + .Add(SyntaxFactory.UsingDirective(SyntaxFactory.ParseName("System"))) + .Add(SyntaxFactory.UsingDirective(SyntaxFactory.ParseName("System.Collections.Immutable"))) + .Add(SyntaxFactory.UsingDirective(SyntaxFactory.ParseName("System.Reflection"))) + .Add(SyntaxFactory.UsingDirective(SyntaxFactory.ParseName("Microsoft.CodeAnalysis"))) + .Add(SyntaxFactory.UsingDirective(SyntaxFactory.ParseName("Microsoft.CodeAnalysis.CSharp"))), + members: SyntaxFactory.SingletonList(wrapperHelperClass)); + + wrapperNamespace = wrapperNamespace + .NormalizeWhitespace() + .WithLeadingTrivia( + SyntaxFactory.Comment("// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved."), + SyntaxFactory.CarriageReturnLineFeed, + SyntaxFactory.Comment("// Licensed under the MIT License. See LICENSE in the project root for license information."), + SyntaxFactory.CarriageReturnLineFeed, + SyntaxFactory.CarriageReturnLineFeed) + .WithTrailingTrivia( + SyntaxFactory.CarriageReturnLineFeed); + + context.AddSource("SyntaxWrapperHelper.g.cs", SourceText.From(wrapperNamespace.ToFullString(), Encoding.UTF8)); + } + private sealed class SyntaxData { private readonly Dictionary nameToNode; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp7/Lightup/WrapperHelperTests.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp7/Lightup/WrapperHelperTests.cs index 9d74fc0ce9..f056491afc 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp7/Lightup/WrapperHelperTests.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp7/Lightup/WrapperHelperTests.cs @@ -18,7 +18,7 @@ public void VerifyThatAllWrapperClassesArePresent() foreach (var wrapperType in wrapperTypes) { - var wrappedType = WrapperHelper.GetWrappedType(wrapperType); + var wrappedType = SyntaxWrapperHelper.GetWrappedType(wrapperType); Assert.NotNull(wrapperType); } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/WrapperHelper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SyntaxWrapperHelper.g.cs similarity index 61% rename from StyleCop.Analyzers/StyleCop.Analyzers/Lightup/WrapperHelper.cs rename to StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SyntaxWrapperHelper.g.cs index 52e110c4ed..2550fb7686 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/WrapperHelper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SyntaxWrapperHelper.g.cs @@ -9,40 +9,50 @@ namespace StyleCop.Analyzers.Lightup using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; - internal static class WrapperHelper + internal static class SyntaxWrapperHelper { private static readonly ImmutableDictionary WrappedTypes; - - static WrapperHelper() + static SyntaxWrapperHelper() { var csharpCodeAnalysisAssembly = typeof(CSharpSyntaxNode).GetTypeInfo().Assembly; var builder = ImmutableDictionary.CreateBuilder(); - + builder.Add(typeof(BaseObjectCreationExpressionSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(BaseObjectCreationExpressionSyntaxWrapper.WrappedTypeName)); + builder.Add(typeof(BaseParameterSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(BaseParameterSyntaxWrapper.WrappedTypeName)); + builder.Add(typeof(BinaryPatternSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(BinaryPatternSyntaxWrapper.WrappedTypeName)); builder.Add(typeof(CasePatternSwitchLabelSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(CasePatternSwitchLabelSyntaxWrapper.WrappedTypeName)); - - // Prior to C# 7, ForEachStatementSyntax was the base type for all foreach statements. If - // the CommonForEachStatementSyntax type isn't found at runtime, we fall back to using this type instead. - var forEachStatementSyntaxType = csharpCodeAnalysisAssembly.GetType(CommonForEachStatementSyntaxWrapper.WrappedTypeName) - ?? csharpCodeAnalysisAssembly.GetType(CommonForEachStatementSyntaxWrapper.FallbackWrappedTypeName); + var forEachStatementSyntaxType = csharpCodeAnalysisAssembly.GetType(CommonForEachStatementSyntaxWrapper.WrappedTypeName) ?? csharpCodeAnalysisAssembly.GetType(CommonForEachStatementSyntaxWrapper.FallbackWrappedTypeName); builder.Add(typeof(CommonForEachStatementSyntaxWrapper), forEachStatementSyntaxType); - builder.Add(typeof(ConstantPatternSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(ConstantPatternSyntaxWrapper.WrappedTypeName)); builder.Add(typeof(DeclarationExpressionSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(DeclarationExpressionSyntaxWrapper.WrappedTypeName)); builder.Add(typeof(DeclarationPatternSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(DeclarationPatternSyntaxWrapper.WrappedTypeName)); + builder.Add(typeof(DefaultConstraintSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(DefaultConstraintSyntaxWrapper.WrappedTypeName)); builder.Add(typeof(DiscardDesignationSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(DiscardDesignationSyntaxWrapper.WrappedTypeName)); builder.Add(typeof(DiscardPatternSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(DiscardPatternSyntaxWrapper.WrappedTypeName)); + builder.Add(typeof(ExpressionOrPatternSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(ExpressionOrPatternSyntaxWrapper.WrappedTypeName)); builder.Add(typeof(ForEachVariableStatementSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(ForEachVariableStatementSyntaxWrapper.WrappedTypeName)); - builder.Add(typeof(IsPatternExpressionSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(IsPatternExpressionSyntaxWrapper.WrappedTypeName)); + builder.Add(typeof(FunctionPointerCallingConventionSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(FunctionPointerCallingConventionSyntaxWrapper.WrappedTypeName)); + builder.Add(typeof(FunctionPointerParameterListSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(FunctionPointerParameterListSyntaxWrapper.WrappedTypeName)); + builder.Add(typeof(FunctionPointerParameterSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(FunctionPointerParameterSyntaxWrapper.WrappedTypeName)); + builder.Add(typeof(FunctionPointerTypeSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(FunctionPointerTypeSyntaxWrapper.WrappedTypeName)); + builder.Add(typeof(FunctionPointerUnmanagedCallingConventionListSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(FunctionPointerUnmanagedCallingConventionListSyntaxWrapper.WrappedTypeName)); + builder.Add(typeof(FunctionPointerUnmanagedCallingConventionSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(FunctionPointerUnmanagedCallingConventionSyntaxWrapper.WrappedTypeName)); + builder.Add(typeof(ImplicitObjectCreationExpressionSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(ImplicitObjectCreationExpressionSyntaxWrapper.WrappedTypeName)); builder.Add(typeof(ImplicitStackAllocArrayCreationExpressionSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.WrappedTypeName)); + builder.Add(typeof(IsPatternExpressionSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(IsPatternExpressionSyntaxWrapper.WrappedTypeName)); builder.Add(typeof(LocalFunctionStatementSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(LocalFunctionStatementSyntaxWrapper.WrappedTypeName)); + builder.Add(typeof(NullableDirectiveTriviaSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(NullableDirectiveTriviaSyntaxWrapper.WrappedTypeName)); + builder.Add(typeof(ParenthesizedPatternSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(ParenthesizedPatternSyntaxWrapper.WrappedTypeName)); builder.Add(typeof(ParenthesizedVariableDesignationSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(ParenthesizedVariableDesignationSyntaxWrapper.WrappedTypeName)); builder.Add(typeof(PatternSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(PatternSyntaxWrapper.WrappedTypeName)); builder.Add(typeof(PositionalPatternClauseSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(PositionalPatternClauseSyntaxWrapper.WrappedTypeName)); + builder.Add(typeof(PrimaryConstructorBaseTypeSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(PrimaryConstructorBaseTypeSyntaxWrapper.WrappedTypeName)); builder.Add(typeof(PropertyPatternClauseSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(PropertyPatternClauseSyntaxWrapper.WrappedTypeName)); builder.Add(typeof(RangeExpressionSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(RangeExpressionSyntaxWrapper.WrappedTypeName)); + builder.Add(typeof(RecordDeclarationSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(RecordDeclarationSyntaxWrapper.WrappedTypeName)); builder.Add(typeof(RecursivePatternSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(RecursivePatternSyntaxWrapper.WrappedTypeName)); builder.Add(typeof(RefExpressionSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(RefExpressionSyntaxWrapper.WrappedTypeName)); builder.Add(typeof(RefTypeSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(RefTypeSyntaxWrapper.WrappedTypeName)); + builder.Add(typeof(RelationalPatternSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(RelationalPatternSyntaxWrapper.WrappedTypeName)); builder.Add(typeof(SingleVariableDesignationSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(SingleVariableDesignationSyntaxWrapper.WrappedTypeName)); builder.Add(typeof(SubpatternSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(SubpatternSyntaxWrapper.WrappedTypeName)); builder.Add(typeof(SwitchExpressionArmSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(SwitchExpressionArmSyntaxWrapper.WrappedTypeName)); @@ -51,22 +61,18 @@ static WrapperHelper() builder.Add(typeof(TupleElementSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(TupleElementSyntaxWrapper.WrappedTypeName)); builder.Add(typeof(TupleExpressionSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(TupleExpressionSyntaxWrapper.WrappedTypeName)); builder.Add(typeof(TupleTypeSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(TupleTypeSyntaxWrapper.WrappedTypeName)); - builder.Add(typeof(VarPatternSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(VarPatternSyntaxWrapper.WrappedTypeName)); + builder.Add(typeof(TypePatternSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(TypePatternSyntaxWrapper.WrappedTypeName)); + builder.Add(typeof(UnaryPatternSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(UnaryPatternSyntaxWrapper.WrappedTypeName)); builder.Add(typeof(VariableDesignationSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(VariableDesignationSyntaxWrapper.WrappedTypeName)); + builder.Add(typeof(VarPatternSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(VarPatternSyntaxWrapper.WrappedTypeName)); builder.Add(typeof(WhenClauseSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(WhenClauseSyntaxWrapper.WrappedTypeName)); - + builder.Add(typeof(WithExpressionSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(WithExpressionSyntaxWrapper.WrappedTypeName)); WrappedTypes = builder.ToImmutable(); } - /// - /// Gets the type that is wrapped by the given wrapper. - /// - /// Type of the wrapper for which the wrapped type should be retrieved. - /// The wrapped type, or null if there is no info. internal static Type GetWrappedType(Type wrapperType) { - Type wrappedType; - if (WrappedTypes.TryGetValue(wrapperType, out wrappedType)) + if (WrappedTypes.TryGetValue(wrapperType, out Type wrappedType)) { return wrappedType; } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CasePatternSwitchLabelSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CasePatternSwitchLabelSyntaxWrapper.cs index a96ee1149f..3fd041bf30 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CasePatternSwitchLabelSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CasePatternSwitchLabelSyntaxWrapper.cs @@ -19,7 +19,7 @@ internal partial struct CasePatternSwitchLabelSyntaxWrapper : ISyntaxWrapper(WrappedType, nameof(Pattern)); WhenClauseAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(WhenClause)); WithKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(SwitchLabelSyntax.Keyword)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CommonForEachStatementSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CommonForEachStatementSyntaxWrapper.cs index 0e39797f76..da9230c6a2 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CommonForEachStatementSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CommonForEachStatementSyntaxWrapper.cs @@ -29,7 +29,7 @@ internal partial struct CommonForEachStatementSyntaxWrapper : ISyntaxWrapper(WrappedType, nameof(AwaitKeyword)); ForEachKeywordAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(ForEachKeyword)); OpenParenTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(OpenParenToken)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ConstantPatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ConstantPatternSyntaxWrapper.cs index de5e6fc9ea..9f2a5a750d 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ConstantPatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ConstantPatternSyntaxWrapper.cs @@ -15,7 +15,7 @@ internal partial struct ConstantPatternSyntaxWrapper : ISyntaxWrapper(WrappedType, nameof(Expression)); WithExpressionAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Expression)); } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationExpressionSyntaxWrapper.cs index 76f2937472..02f7c6f970 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationExpressionSyntaxWrapper.cs @@ -17,7 +17,7 @@ internal partial struct DeclarationExpressionSyntaxWrapper : ISyntaxWrapper(WrappedType, nameof(Type)); DesignationAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Designation)); WithTypeAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Type)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationPatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationPatternSyntaxWrapper.cs index f08697fcd3..759a914d3e 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationPatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationPatternSyntaxWrapper.cs @@ -17,7 +17,7 @@ internal partial struct DeclarationPatternSyntaxWrapper : ISyntaxWrapper(WrappedType, nameof(Type)); DesignationAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Designation)); WithTypeAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Type)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardDesignationSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardDesignationSyntaxWrapper.cs index 2d51ff1be7..8b0585e886 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardDesignationSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardDesignationSyntaxWrapper.cs @@ -14,7 +14,7 @@ internal partial struct DiscardDesignationSyntaxWrapper : ISyntaxWrapper(WrappedType, nameof(UnderscoreToken)); WithUnderscoreTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(UnderscoreToken)); } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardPatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardPatternSyntaxWrapper.cs index 7d8e9ec910..bac3f84206 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardPatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardPatternSyntaxWrapper.cs @@ -14,7 +14,7 @@ internal partial struct DiscardPatternSyntaxWrapper : ISyntaxWrapper(WrappedType, nameof(UnderscoreToken)); WithUnderscoreTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(UnderscoreToken)); } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ForEachVariableStatementSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ForEachVariableStatementSyntaxWrapper.cs index 5326051a26..9bd90ae5bc 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ForEachVariableStatementSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ForEachVariableStatementSyntaxWrapper.cs @@ -22,7 +22,7 @@ internal partial struct ForEachVariableStatementSyntaxWrapper : ISyntaxWrapper(WrappedType, nameof(Variable)); WithAwaitKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(AwaitKeyword)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.cs index 842022e0dc..46bf4daac6 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.cs @@ -20,7 +20,7 @@ internal partial struct ImplicitStackAllocArrayCreationExpressionSyntaxWrapper : static ImplicitStackAllocArrayCreationExpressionSyntaxWrapper() { - WrappedType = WrapperHelper.GetWrappedType(typeof(ImplicitStackAllocArrayCreationExpressionSyntaxWrapper)); + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(ImplicitStackAllocArrayCreationExpressionSyntaxWrapper)); StackAllocKeywordAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(StackAllocKeyword)); OpenBracketTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(OpenBracketToken)); CloseBracketTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(CloseBracketToken)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/IsPatternExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/IsPatternExpressionSyntaxWrapper.cs index 91a5046d54..c05f554ec2 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/IsPatternExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/IsPatternExpressionSyntaxWrapper.cs @@ -19,7 +19,7 @@ internal partial struct IsPatternExpressionSyntaxWrapper : ISyntaxWrapper(WrappedType, nameof(Expression)); IsKeywordAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(IsKeyword)); PatternAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Pattern)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/LightupHelpers.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/LightupHelpers.cs index b3af495843..a2bfc224b6 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/LightupHelpers.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/LightupHelpers.cs @@ -449,7 +449,7 @@ TSyntax FallbackAccessor(TSyntax syntax, SeparatedSyntaxListWrapper n private static bool ValidatePropertyType(Type returnType, Type actualType) { - var requiredType = WrapperHelper.GetWrappedType(returnType) ?? returnType; + var requiredType = SyntaxWrapperHelper.GetWrappedType(returnType) ?? returnType; return requiredType == actualType; } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/LocalFunctionStatementSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/LocalFunctionStatementSyntaxWrapper.cs index f4d1122d7e..94e06af962 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/LocalFunctionStatementSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/LocalFunctionStatementSyntaxWrapper.cs @@ -31,7 +31,7 @@ internal partial struct LocalFunctionStatementSyntaxWrapper : ISyntaxWrapper(WrappedType, nameof(Modifiers)); ReturnTypeAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(ReturnType)); IdentifierAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Identifier)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ParenthesizedVariableDesignationSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ParenthesizedVariableDesignationSyntaxWrapper.cs index 130cf7c16b..5911c66bfa 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ParenthesizedVariableDesignationSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ParenthesizedVariableDesignationSyntaxWrapper.cs @@ -18,7 +18,7 @@ internal partial struct ParenthesizedVariableDesignationSyntaxWrapper : ISyntaxW static ParenthesizedVariableDesignationSyntaxWrapper() { - WrappedType = WrapperHelper.GetWrappedType(typeof(ParenthesizedVariableDesignationSyntaxWrapper)); + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(ParenthesizedVariableDesignationSyntaxWrapper)); OpenParenTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(OpenParenToken)); VariablesAccessor = LightupHelpers.CreateSeparatedSyntaxListPropertyAccessor(WrappedType, nameof(Variables)); CloseParenTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(CloseParenToken)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PatternSyntaxWrapper.cs index b64b1db9c6..4d7c09ece9 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PatternSyntaxWrapper.cs @@ -11,7 +11,7 @@ internal partial struct PatternSyntaxWrapper : ISyntaxWrapper { static PatternSyntaxWrapper() { - WrappedType = WrapperHelper.GetWrappedType(typeof(PatternSyntaxWrapper)); + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(PatternSyntaxWrapper)); } internal static PatternSyntaxWrapper FromUpcast(CSharpSyntaxNode node) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PositionalPatternClauseSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PositionalPatternClauseSyntaxWrapper.cs index f212da6bf1..dd7e8693a5 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PositionalPatternClauseSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PositionalPatternClauseSyntaxWrapper.cs @@ -19,7 +19,7 @@ internal partial struct PositionalPatternClauseSyntaxWrapper : ISyntaxWrapper(WrappedType, nameof(OpenParenToken)); SubpatternsAccessor = LightupHelpers.CreateSeparatedSyntaxListPropertyAccessor(WrappedType, nameof(Subpatterns)); CloseParenTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(CloseParenToken)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PropertyPatternClauseSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PropertyPatternClauseSyntaxWrapper.cs index 4c30278054..54898b16dc 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PropertyPatternClauseSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PropertyPatternClauseSyntaxWrapper.cs @@ -19,7 +19,7 @@ internal partial struct PropertyPatternClauseSyntaxWrapper : ISyntaxWrapper(WrappedType, nameof(OpenBraceToken)); SubpatternsAccessor = LightupHelpers.CreateSeparatedSyntaxListPropertyAccessor(WrappedType, nameof(Subpatterns)); CloseBraceTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(CloseBraceToken)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RangeExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RangeExpressionSyntaxWrapper.cs index 2f06de449a..2debdd738f 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RangeExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RangeExpressionSyntaxWrapper.cs @@ -19,7 +19,7 @@ internal partial struct RangeExpressionSyntaxWrapper : ISyntaxWrapper(WrappedType, nameof(LeftOperand)); OperatorTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(OperatorToken)); RightOperandAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(RightOperand)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RecursivePatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RecursivePatternSyntaxWrapper.cs index 6e0749a4d5..78c4dbe826 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RecursivePatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RecursivePatternSyntaxWrapper.cs @@ -22,7 +22,7 @@ internal partial struct RecursivePatternSyntaxWrapper : ISyntaxWrapper(WrappedType, nameof(Type)); PositionalPatternClauseAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(PositionalPatternClause)); PropertyPatternClauseAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(PropertyPatternClause)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefExpressionSyntaxWrapper.cs index 2938476e52..8610b6903c 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefExpressionSyntaxWrapper.cs @@ -16,7 +16,7 @@ internal partial struct RefExpressionSyntaxWrapper : ISyntaxWrapper(WrappedType, nameof(RefKeyword)); ExpressionAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Expression)); WithRefKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(RefKeyword)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefTypeSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefTypeSyntaxWrapper.cs index 79bbd046e9..1757928bfb 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefTypeSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefTypeSyntaxWrapper.cs @@ -18,7 +18,7 @@ internal partial struct RefTypeSyntaxWrapper : ISyntaxWrapper static RefTypeSyntaxWrapper() { - WrappedType = WrapperHelper.GetWrappedType(typeof(RefTypeSyntaxWrapper)); + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(RefTypeSyntaxWrapper)); RefKeywordAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(RefKeyword)); ReadOnlyKeywordAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(ReadOnlyKeyword)); TypeAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Type)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SingleVariableDesignationSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SingleVariableDesignationSyntaxWrapper.cs index e2051938e6..a30a36b980 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SingleVariableDesignationSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SingleVariableDesignationSyntaxWrapper.cs @@ -14,7 +14,7 @@ internal partial struct SingleVariableDesignationSyntaxWrapper : ISyntaxWrapper< static SingleVariableDesignationSyntaxWrapper() { - WrappedType = WrapperHelper.GetWrappedType(typeof(SingleVariableDesignationSyntaxWrapper)); + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(SingleVariableDesignationSyntaxWrapper)); IdentifierAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Identifier)); WithIdentifierAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Identifier)); } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SubpatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SubpatternSyntaxWrapper.cs index 0575db41ec..70f0be3d9c 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SubpatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SubpatternSyntaxWrapper.cs @@ -18,7 +18,7 @@ internal partial struct SubpatternSyntaxWrapper : ISyntaxWrapper(WrappedType, nameof(NameColon)); PatternAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Pattern)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionArmSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionArmSyntaxWrapper.cs index 7d3527df21..35d12572bf 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionArmSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionArmSyntaxWrapper.cs @@ -22,7 +22,7 @@ internal partial struct SwitchExpressionArmSyntaxWrapper : ISyntaxWrapper(WrappedType, nameof(Pattern)); WhenClauseAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(WhenClause)); ExpressionAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Expression)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionSyntaxWrapper.cs index 45f715f53c..533e531557 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionSyntaxWrapper.cs @@ -23,7 +23,7 @@ internal partial struct SwitchExpressionSyntaxWrapper : ISyntaxWrapper(WrappedType, nameof(Arms)); GoverningExpressionAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(GoverningExpression)); OpenBraceTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(OpenBraceToken)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SyntaxFactoryEx.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SyntaxFactoryEx.cs index 4a1a8e35c8..e4999cb5a9 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SyntaxFactoryEx.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SyntaxFactoryEx.cs @@ -27,7 +27,7 @@ internal static class SyntaxFactoryEx static SyntaxFactoryEx() { var positionalPatternClauseMethods = typeof(SyntaxFactory).GetTypeInfo().GetDeclaredMethods(nameof(PositionalPatternClause)); - var positionalPatternClauseMethod = positionalPatternClauseMethods.FirstOrDefault(method => method.GetParameters().Length == 1 && method.GetParameters()[0].ParameterType == typeof(SeparatedSyntaxList<>).MakeGenericType(WrapperHelper.GetWrappedType(typeof(SubpatternSyntaxWrapper)))); + var positionalPatternClauseMethod = positionalPatternClauseMethods.FirstOrDefault(method => method.GetParameters().Length == 1 && method.GetParameters()[0].ParameterType == typeof(SeparatedSyntaxList<>).MakeGenericType(SyntaxWrapperHelper.GetWrappedType(typeof(SubpatternSyntaxWrapper)))); if (positionalPatternClauseMethod is object) { var subpatternsParameter = Expression.Parameter(typeof(SeparatedSyntaxListWrapper), "subpatterns"); @@ -49,7 +49,7 @@ static SyntaxFactoryEx() positionalPatternClauseMethod = positionalPatternClauseMethods.FirstOrDefault(method => method.GetParameters().Length == 3 && method.GetParameters()[0].ParameterType == typeof(SyntaxToken) - && method.GetParameters()[1].ParameterType == typeof(SeparatedSyntaxList<>).MakeGenericType(WrapperHelper.GetWrappedType(typeof(SubpatternSyntaxWrapper))) + && method.GetParameters()[1].ParameterType == typeof(SeparatedSyntaxList<>).MakeGenericType(SyntaxWrapperHelper.GetWrappedType(typeof(SubpatternSyntaxWrapper))) && method.GetParameters()[2].ParameterType == typeof(SyntaxToken)); if (positionalPatternClauseMethod is object) { @@ -79,7 +79,7 @@ static SyntaxFactoryEx() } var propertyPatternClauseMethods = typeof(SyntaxFactory).GetTypeInfo().GetDeclaredMethods(nameof(PropertyPatternClause)); - var propertyPatternClauseMethod = propertyPatternClauseMethods.FirstOrDefault(method => method.GetParameters().Length == 1 && method.GetParameters()[0].ParameterType == typeof(SeparatedSyntaxList<>).MakeGenericType(WrapperHelper.GetWrappedType(typeof(SubpatternSyntaxWrapper)))); + var propertyPatternClauseMethod = propertyPatternClauseMethods.FirstOrDefault(method => method.GetParameters().Length == 1 && method.GetParameters()[0].ParameterType == typeof(SeparatedSyntaxList<>).MakeGenericType(SyntaxWrapperHelper.GetWrappedType(typeof(SubpatternSyntaxWrapper)))); if (propertyPatternClauseMethod is object) { var subpatternsParameter = Expression.Parameter(typeof(SeparatedSyntaxListWrapper), "subpatterns"); @@ -101,7 +101,7 @@ static SyntaxFactoryEx() propertyPatternClauseMethod = propertyPatternClauseMethods.FirstOrDefault(method => method.GetParameters().Length == 3 && method.GetParameters()[0].ParameterType == typeof(SyntaxToken) - && method.GetParameters()[1].ParameterType == typeof(SeparatedSyntaxList<>).MakeGenericType(WrapperHelper.GetWrappedType(typeof(SubpatternSyntaxWrapper))) + && method.GetParameters()[1].ParameterType == typeof(SeparatedSyntaxList<>).MakeGenericType(SyntaxWrapperHelper.GetWrappedType(typeof(SubpatternSyntaxWrapper))) && method.GetParameters()[2].ParameterType == typeof(SyntaxToken)); if (propertyPatternClauseMethod is object) { @@ -202,7 +202,7 @@ static SyntaxFactoryEx() } var tupleTypeMethods = typeof(SyntaxFactory).GetTypeInfo().GetDeclaredMethods(nameof(TupleType)); - var tupleTypeMethod = tupleTypeMethods.FirstOrDefault(method => method.GetParameters().Length == 1 && method.GetParameters()[0].ParameterType == typeof(SeparatedSyntaxList<>).MakeGenericType(WrapperHelper.GetWrappedType(typeof(TupleElementSyntaxWrapper)))); + var tupleTypeMethod = tupleTypeMethods.FirstOrDefault(method => method.GetParameters().Length == 1 && method.GetParameters()[0].ParameterType == typeof(SeparatedSyntaxList<>).MakeGenericType(SyntaxWrapperHelper.GetWrappedType(typeof(TupleElementSyntaxWrapper)))); if (tupleTypeMethod is object) { var elementsParameter = Expression.Parameter(typeof(SeparatedSyntaxListWrapper), "elements"); @@ -224,7 +224,7 @@ static SyntaxFactoryEx() tupleTypeMethod = tupleTypeMethods.FirstOrDefault(method => method.GetParameters().Length == 3 && method.GetParameters()[0].ParameterType == typeof(SyntaxToken) - && method.GetParameters()[1].ParameterType == typeof(SeparatedSyntaxList<>).MakeGenericType(WrapperHelper.GetWrappedType(typeof(TupleElementSyntaxWrapper))) + && method.GetParameters()[1].ParameterType == typeof(SeparatedSyntaxList<>).MakeGenericType(SyntaxWrapperHelper.GetWrappedType(typeof(TupleElementSyntaxWrapper))) && method.GetParameters()[2].ParameterType == typeof(SyntaxToken)); if (tupleTypeMethod is object) { diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ThrowExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ThrowExpressionSyntaxWrapper.cs index b561cca0d9..ac64a5fc9c 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ThrowExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ThrowExpressionSyntaxWrapper.cs @@ -16,7 +16,7 @@ internal partial struct ThrowExpressionSyntaxWrapper : ISyntaxWrapper(WrappedType, nameof(ThrowKeyword)); ExpressionAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Expression)); WithThrowKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(ThrowKeyword)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleElementSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleElementSyntaxWrapper.cs index ef0f009120..28274a7a1e 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleElementSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleElementSyntaxWrapper.cs @@ -17,7 +17,7 @@ internal partial struct TupleElementSyntaxWrapper : ISyntaxWrapper(WrappedType, nameof(Identifier)); TypeAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Type)); WithIdentifierAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Identifier)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleExpressionSyntaxWrapper.cs index 09fd37ff88..98f95c6e00 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleExpressionSyntaxWrapper.cs @@ -18,7 +18,7 @@ internal partial struct TupleExpressionSyntaxWrapper : ISyntaxWrapper(WrappedType, nameof(OpenParenToken)); ArgumentsAccessor = LightupHelpers.CreateSyntaxPropertyAccessor>(WrappedType, nameof(Arguments)); CloseParenTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(CloseParenToken)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleTypeSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleTypeSyntaxWrapper.cs index 4f472e424c..b5f62909ed 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleTypeSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleTypeSyntaxWrapper.cs @@ -18,7 +18,7 @@ internal partial struct TupleTypeSyntaxWrapper : ISyntaxWrapper static TupleTypeSyntaxWrapper() { - WrappedType = WrapperHelper.GetWrappedType(typeof(TupleTypeSyntaxWrapper)); + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(TupleTypeSyntaxWrapper)); OpenParenTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(OpenParenToken)); ElementsAccessor = LightupHelpers.CreateSeparatedSyntaxListPropertyAccessor(WrappedType, nameof(Elements)); CloseParenTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(CloseParenToken)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VarPatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VarPatternSyntaxWrapper.cs index 4df0c059e4..7655fb6854 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VarPatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VarPatternSyntaxWrapper.cs @@ -17,7 +17,7 @@ internal partial struct VarPatternSyntaxWrapper : ISyntaxWrapper(WrappedType, nameof(VarKeyword)); DesignationAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Designation)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VariableDesignationSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VariableDesignationSyntaxWrapper.cs index cbf6adefb7..dcaad192fd 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VariableDesignationSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VariableDesignationSyntaxWrapper.cs @@ -11,7 +11,7 @@ internal partial struct VariableDesignationSyntaxWrapper : ISyntaxWrapper(WrappedType, nameof(WhenKeyword)); ConditionAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Condition)); WithWhenKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(WhenKeyword)); From 056110d9fcbe3eac1175ff8bc78341bfc66ef0bc Mon Sep 17 00:00:00 2001 From: Sam Harwell Date: Mon, 16 Nov 2020 20:50:04 -0800 Subject: [PATCH 06/18] Update SyntaxWrapperHelperTests --- .../SyntaxWrapperHelperTestsCSharp7.cs | 11 ++++ .../Lightup/WrapperHelperTests.cs | 26 --------- ....cs => SyntaxWrapperHelperTestsCSharp8.cs} | 2 +- ....cs => SyntaxWrapperHelperTestsCSharp9.cs} | 2 +- .../Lightup/SyntaxWrapperHelperTests.cs | 53 +++++++++++++++++++ 5 files changed, 66 insertions(+), 28 deletions(-) create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp7/Lightup/SyntaxWrapperHelperTestsCSharp7.cs delete mode 100644 StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp7/Lightup/WrapperHelperTests.cs rename StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp8/Lightup/{WrapperHelperTestsCSharp8.cs => SyntaxWrapperHelperTestsCSharp8.cs} (77%) rename StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp9/Lightup/{WrapperHelperTestsCSharp9.cs => SyntaxWrapperHelperTestsCSharp9.cs} (77%) create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers.Test/Lightup/SyntaxWrapperHelperTests.cs diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp7/Lightup/SyntaxWrapperHelperTestsCSharp7.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp7/Lightup/SyntaxWrapperHelperTestsCSharp7.cs new file mode 100644 index 0000000000..0e17cde56f --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp7/Lightup/SyntaxWrapperHelperTestsCSharp7.cs @@ -0,0 +1,11 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Test.CSharp7.Lightup +{ + using StyleCop.Analyzers.Test.Lightup; + + public class SyntaxWrapperHelperTestsCSharp7 : SyntaxWrapperHelperTests + { + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp7/Lightup/WrapperHelperTests.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp7/Lightup/WrapperHelperTests.cs deleted file mode 100644 index f056491afc..0000000000 --- a/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp7/Lightup/WrapperHelperTests.cs +++ /dev/null @@ -1,26 +0,0 @@ -// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. -// Licensed under the MIT License. See LICENSE in the project root for license information. - -namespace StyleCop.Analyzers.Test.CSharp7.Lightup -{ - using System.Linq; - using System.Reflection; - using StyleCop.Analyzers.Lightup; - using Xunit; - - public class WrapperHelperTests - { - [Fact] - public void VerifyThatAllWrapperClassesArePresent() - { - var wrapperTypes = typeof(ISyntaxWrapper<>).Assembly.GetTypes() - .Where(t => t.GetTypeInfo().ImplementedInterfaces.Any(i => i.IsGenericType && (i.GetGenericTypeDefinition() == typeof(ISyntaxWrapper<>)))); - - foreach (var wrapperType in wrapperTypes) - { - var wrappedType = SyntaxWrapperHelper.GetWrappedType(wrapperType); - Assert.NotNull(wrapperType); - } - } - } -} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp8/Lightup/WrapperHelperTestsCSharp8.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp8/Lightup/SyntaxWrapperHelperTestsCSharp8.cs similarity index 77% rename from StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp8/Lightup/WrapperHelperTestsCSharp8.cs rename to StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp8/Lightup/SyntaxWrapperHelperTestsCSharp8.cs index 6c4c96091d..de7ed0073c 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp8/Lightup/WrapperHelperTestsCSharp8.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp8/Lightup/SyntaxWrapperHelperTestsCSharp8.cs @@ -5,7 +5,7 @@ namespace StyleCop.Analyzers.Test.CSharp8.Lightup { using StyleCop.Analyzers.Test.CSharp7.Lightup; - public class WrapperHelperTestsCSharp8 : WrapperHelperTests + public class SyntaxWrapperHelperTestsCSharp8 : SyntaxWrapperHelperTestsCSharp7 { } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp9/Lightup/WrapperHelperTestsCSharp9.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp9/Lightup/SyntaxWrapperHelperTestsCSharp9.cs similarity index 77% rename from StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp9/Lightup/WrapperHelperTestsCSharp9.cs rename to StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp9/Lightup/SyntaxWrapperHelperTestsCSharp9.cs index 132b525270..7df0a8adf9 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp9/Lightup/WrapperHelperTestsCSharp9.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp9/Lightup/SyntaxWrapperHelperTestsCSharp9.cs @@ -5,7 +5,7 @@ namespace StyleCop.Analyzers.Test.CSharp9.Lightup { using StyleCop.Analyzers.Test.CSharp8.Lightup; - public class WrapperHelperTestsCSharp9 : WrapperHelperTestsCSharp8 + public class SyntaxWrapperHelperTestsCSharp9 : SyntaxWrapperHelperTestsCSharp8 { } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test/Lightup/SyntaxWrapperHelperTests.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test/Lightup/SyntaxWrapperHelperTests.cs new file mode 100644 index 0000000000..c32f0ced7e --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers.Test/Lightup/SyntaxWrapperHelperTests.cs @@ -0,0 +1,53 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Test.Lightup +{ + using System; + using System.Collections.Generic; + using System.Linq; + using System.Reflection; + using Microsoft.CodeAnalysis.CSharp; + using Microsoft.CodeAnalysis.CSharp.Syntax; + using StyleCop.Analyzers.Lightup; + using Xunit; + + public class SyntaxWrapperHelperTests + { + public static IEnumerable SyntaxWrapperClasses + { + get + { + var wrapperTypes = typeof(ISyntaxWrapper<>).Assembly.GetTypes() + .Where(t => t.GetTypeInfo().ImplementedInterfaces.Any(i => i.IsGenericType && (i.GetGenericTypeDefinition() == typeof(ISyntaxWrapper<>)))); + + foreach (var wrapperType in wrapperTypes) + { + yield return new object[] { wrapperType }; + } + } + } + + [Theory] + [MemberData(nameof(SyntaxWrapperClasses))] + public void VerifyThatWrapperClassIsPresent(Type wrapperType) + { + var wrappedTypeName = $"Microsoft.CodeAnalysis.CSharp.Syntax.{wrapperType.Name.Substring(0, wrapperType.Name.Length - "Wrapper".Length)}"; + if (typeof(CSharpSyntaxNode).Assembly.GetType(wrappedTypeName) is { } expected) + { + var wrappedType = SyntaxWrapperHelper.GetWrappedType(wrapperType); + Assert.Same(expected, wrappedType); + } + else if (wrapperType == typeof(CommonForEachStatementSyntaxWrapper)) + { + // Special case for C# 6 analysis compatibility + Assert.False(LightupHelpers.SupportsCSharp7); + Assert.Same(typeof(ForEachStatementSyntax), SyntaxWrapperHelper.GetWrappedType(wrapperType)); + } + else + { + Assert.Null(SyntaxWrapperHelper.GetWrappedType(wrapperType)); + } + } + } +} From fa7ed322da1b1c08fde530734d2a2388b7b662ce Mon Sep 17 00:00:00 2001 From: Sam Harwell Date: Mon, 16 Nov 2020 21:00:02 -0800 Subject: [PATCH 07/18] Generate FromUpcast helper --- .../SyntaxLightupGenerator.cs | 28 +++++++++++++++++++ ...ObjectCreationExpressionSyntaxWrapper.g.cs | 5 ++++ .../BaseParameterSyntaxWrapper.g.cs | 5 ++++ .../CommonForEachStatementSyntaxWrapper.g.cs | 5 ++++ .../ExpressionOrPatternSyntaxWrapper.g.cs | 5 ++++ .../PatternSyntaxWrapper.g.cs | 5 ++++ .../VariableDesignationSyntaxWrapper.g.cs | 5 ++++ .../CommonForEachStatementSyntaxWrapper.cs | 5 ---- .../Lightup/PatternSyntaxWrapper.cs | 7 ----- .../VariableDesignationSyntaxWrapper.cs | 7 ----- 10 files changed, 58 insertions(+), 19 deletions(-) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs b/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs index 636a933ae6..14524e695f 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs @@ -276,6 +276,34 @@ private void GenerateSyntaxWrapper(in GeneratorExecutionContext context, SyntaxD })))))), expressionBody: null)); + if (nodeData.Kind == NodeKind.Abstract) + { + // internal static SyntaxWrapper FromUpcast(CSharpSyntaxNode node) + // { + // return new SyntaxWrapper(node); + // } + members = members.Add(SyntaxFactory.MethodDeclaration( + attributeLists: default, + modifiers: SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.InternalKeyword), SyntaxFactory.Token(SyntaxKind.StaticKeyword)), + returnType: SyntaxFactory.IdentifierName(nodeData.WrapperName), + explicitInterfaceSpecifier: null, + identifier: SyntaxFactory.Identifier("FromUpcast"), + typeParameterList: null, + parameterList: SyntaxFactory.ParameterList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Parameter( + attributeLists: default, + modifiers: default, + type: SyntaxFactory.IdentifierName(concreteBase), + identifier: SyntaxFactory.Identifier("node"), + @default: null))), + constraintClauses: default, + body: SyntaxFactory.Block( + SyntaxFactory.ReturnStatement(SyntaxFactory.ObjectCreationExpression( + type: SyntaxFactory.IdentifierName(nodeData.WrapperName), + argumentList: SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Argument(SyntaxFactory.IdentifierName("node")))), + initializer: null))), + expressionBody: null)); + } + var wrapperStruct = SyntaxFactory.StructDeclaration( attributeLists: default, modifiers: SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.InternalKeyword), SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword), SyntaxFactory.Token(SyntaxKind.PartialKeyword)), diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseObjectCreationExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseObjectCreationExpressionSyntaxWrapper.g.cs index 53906c41d8..9bf854e7dc 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseObjectCreationExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseObjectCreationExpressionSyntaxWrapper.g.cs @@ -44,5 +44,10 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + internal static BaseObjectCreationExpressionSyntaxWrapper FromUpcast(ExpressionSyntax node) + { + return new BaseObjectCreationExpressionSyntaxWrapper(node); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseParameterSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseParameterSyntaxWrapper.g.cs index 6c501eb18d..f34b98dd7c 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseParameterSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseParameterSyntaxWrapper.g.cs @@ -44,5 +44,10 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + internal static BaseParameterSyntaxWrapper FromUpcast(CSharpSyntaxNode node) + { + return new BaseParameterSyntaxWrapper(node); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CommonForEachStatementSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CommonForEachStatementSyntaxWrapper.g.cs index 383436e52e..7144baac92 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CommonForEachStatementSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CommonForEachStatementSyntaxWrapper.g.cs @@ -44,5 +44,10 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + internal static CommonForEachStatementSyntaxWrapper FromUpcast(StatementSyntax node) + { + return new CommonForEachStatementSyntaxWrapper(node); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ExpressionOrPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ExpressionOrPatternSyntaxWrapper.g.cs index 6d697acf92..2a1564ab58 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ExpressionOrPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ExpressionOrPatternSyntaxWrapper.g.cs @@ -44,5 +44,10 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + internal static ExpressionOrPatternSyntaxWrapper FromUpcast(CSharpSyntaxNode node) + { + return new ExpressionOrPatternSyntaxWrapper(node); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PatternSyntaxWrapper.g.cs index df8b011e0c..4b2104546a 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PatternSyntaxWrapper.g.cs @@ -44,5 +44,10 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + internal static PatternSyntaxWrapper FromUpcast(CSharpSyntaxNode node) + { + return new PatternSyntaxWrapper(node); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VariableDesignationSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VariableDesignationSyntaxWrapper.g.cs index f325ae5f2c..f03a004491 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VariableDesignationSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VariableDesignationSyntaxWrapper.g.cs @@ -44,5 +44,10 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + internal static VariableDesignationSyntaxWrapper FromUpcast(CSharpSyntaxNode node) + { + return new VariableDesignationSyntaxWrapper(node); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CommonForEachStatementSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CommonForEachStatementSyntaxWrapper.cs index da9230c6a2..7423f1fe7b 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CommonForEachStatementSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CommonForEachStatementSyntaxWrapper.cs @@ -142,10 +142,5 @@ public CommonForEachStatementSyntaxWrapper WithStatement(StatementSyntax stateme { return new CommonForEachStatementSyntaxWrapper(WithStatementAccessor(this.SyntaxNode, statement)); } - - internal static CommonForEachStatementSyntaxWrapper FromUpcast(StatementSyntax node) - { - return new CommonForEachStatementSyntaxWrapper(node); - } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PatternSyntaxWrapper.cs index 4d7c09ece9..d14851e6b4 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PatternSyntaxWrapper.cs @@ -3,8 +3,6 @@ namespace StyleCop.Analyzers.Lightup { - using System; - using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; internal partial struct PatternSyntaxWrapper : ISyntaxWrapper @@ -13,10 +11,5 @@ static PatternSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(PatternSyntaxWrapper)); } - - internal static PatternSyntaxWrapper FromUpcast(CSharpSyntaxNode node) - { - return new PatternSyntaxWrapper(node); - } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VariableDesignationSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VariableDesignationSyntaxWrapper.cs index dcaad192fd..b841a5af00 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VariableDesignationSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VariableDesignationSyntaxWrapper.cs @@ -3,8 +3,6 @@ namespace StyleCop.Analyzers.Lightup { - using System; - using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; internal partial struct VariableDesignationSyntaxWrapper : ISyntaxWrapper @@ -13,10 +11,5 @@ static VariableDesignationSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(VariableDesignationSyntaxWrapper)); } - - internal static VariableDesignationSyntaxWrapper FromUpcast(CSharpSyntaxNode node) - { - return new VariableDesignationSyntaxWrapper(node); - } } } From 80f3eaf8e94be95473def7b4b399b4ed1e10fa4c Mon Sep 17 00:00:00 2001 From: Sam Harwell Date: Mon, 16 Nov 2020 22:15:09 -0800 Subject: [PATCH 08/18] Generate property accessors --- .../SyntaxLightupGenerator.cs | 105 +++++++++++++++++- ...ObjectCreationExpressionSyntaxWrapper.g.cs | 6 + .../BaseParameterSyntaxWrapper.g.cs | 6 + .../BinaryPatternSyntaxWrapper.g.cs | 6 + .../CasePatternSwitchLabelSyntaxWrapper.g.cs | 6 + .../CommonForEachStatementSyntaxWrapper.g.cs | 14 +++ .../ConstantPatternSyntaxWrapper.g.cs | 2 + .../DeclarationExpressionSyntaxWrapper.g.cs | 4 + .../DeclarationPatternSyntaxWrapper.g.cs | 4 + .../DefaultConstraintSyntaxWrapper.g.cs | 2 + .../DiscardDesignationSyntaxWrapper.g.cs | 2 + .../DiscardPatternSyntaxWrapper.g.cs | 2 + ...ForEachVariableStatementSyntaxWrapper.g.cs | 10 ++ ...PointerCallingConventionSyntaxWrapper.g.cs | 4 + ...tionPointerParameterListSyntaxWrapper.g.cs | 6 + ...FunctionPointerParameterSyntaxWrapper.g.cs | 3 + .../FunctionPointerTypeSyntaxWrapper.g.cs | 8 ++ ...gedCallingConventionListSyntaxWrapper.g.cs | 6 + ...managedCallingConventionSyntaxWrapper.g.cs | 2 + ...ObjectCreationExpressionSyntaxWrapper.g.cs | 3 + ...cArrayCreationExpressionSyntaxWrapper.g.cs | 8 ++ .../IsPatternExpressionSyntaxWrapper.g.cs | 6 + .../LocalFunctionStatementSyntaxWrapper.g.cs | 19 ++++ .../NullableDirectiveTriviaSyntaxWrapper.g.cs | 9 ++ .../ParenthesizedPatternSyntaxWrapper.g.cs | 6 + ...sizedVariableDesignationSyntaxWrapper.g.cs | 6 + .../PositionalPatternClauseSyntaxWrapper.g.cs | 6 + ...imaryConstructorBaseTypeSyntaxWrapper.g.cs | 3 + .../PropertyPatternClauseSyntaxWrapper.g.cs | 6 + .../RangeExpressionSyntaxWrapper.g.cs | 6 + .../RecordDeclarationSyntaxWrapper.g.cs | 13 +++ .../RecursivePatternSyntaxWrapper.g.cs | 8 ++ .../RefExpressionSyntaxWrapper.g.cs | 4 + .../RefTypeSyntaxWrapper.g.cs | 6 + .../RelationalPatternSyntaxWrapper.g.cs | 4 + ...ingleVariableDesignationSyntaxWrapper.g.cs | 2 + .../SubpatternSyntaxWrapper.g.cs | 4 + .../SwitchExpressionArmSyntaxWrapper.g.cs | 8 ++ .../SwitchExpressionSyntaxWrapper.g.cs | 10 ++ .../ThrowExpressionSyntaxWrapper.g.cs | 4 + .../TupleElementSyntaxWrapper.g.cs | 4 + .../TupleExpressionSyntaxWrapper.g.cs | 6 + .../TupleTypeSyntaxWrapper.g.cs | 6 + .../TypePatternSyntaxWrapper.g.cs | 2 + .../UnaryPatternSyntaxWrapper.g.cs | 4 + .../VarPatternSyntaxWrapper.g.cs | 4 + .../WhenClauseSyntaxWrapper.g.cs | 4 + .../WithExpressionSyntaxWrapper.g.cs | 6 + .../CasePatternSwitchLabelSyntaxWrapper.cs | 8 -- .../CommonForEachStatementSyntaxWrapper.cs | 17 --- .../Lightup/ConstantPatternSyntaxWrapper.cs | 5 - .../DeclarationExpressionSyntaxWrapper.cs | 7 -- .../DeclarationPatternSyntaxWrapper.cs | 7 -- .../DiscardDesignationSyntaxWrapper.cs | 4 - .../Lightup/DiscardPatternSyntaxWrapper.cs | 4 - .../ForEachVariableStatementSyntaxWrapper.cs | 12 -- ...locArrayCreationExpressionSyntaxWrapper.cs | 10 -- .../IsPatternExpressionSyntaxWrapper.cs | 8 -- .../LocalFunctionStatementSyntaxWrapper.cs | 20 ---- ...hesizedVariableDesignationSyntaxWrapper.cs | 8 -- .../PositionalPatternClauseSyntaxWrapper.cs | 9 -- .../PropertyPatternClauseSyntaxWrapper.cs | 9 -- .../Lightup/RangeExpressionSyntaxWrapper.cs | 9 -- .../Lightup/RecursivePatternSyntaxWrapper.cs | 12 -- .../Lightup/RefExpressionSyntaxWrapper.cs | 6 - .../Lightup/RefTypeSyntaxWrapper.cs | 8 -- .../SingleVariableDesignationSyntaxWrapper.cs | 4 - .../Lightup/SubpatternSyntaxWrapper.cs | 8 -- .../SwitchExpressionArmSyntaxWrapper.cs | 11 -- .../Lightup/SwitchExpressionSyntaxWrapper.cs | 13 --- .../Lightup/ThrowExpressionSyntaxWrapper.cs | 6 - .../Lightup/TupleElementSyntaxWrapper.cs | 6 - .../Lightup/TupleExpressionSyntaxWrapper.cs | 8 -- .../Lightup/TupleTypeSyntaxWrapper.cs | 8 -- .../Lightup/VarPatternSyntaxWrapper.cs | 7 -- .../Lightup/WhenClauseSyntaxWrapper.cs | 6 - 76 files changed, 370 insertions(+), 245 deletions(-) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs b/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs index 14524e695f..dd9c4826a9 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs @@ -88,6 +88,59 @@ private void GenerateSyntaxWrapper(in GeneratorExecutionContext context, SyntaxD type: SyntaxFactory.IdentifierName(concreteBase), variables: SyntaxFactory.SingletonSeparatedList(SyntaxFactory.VariableDeclarator("node"))))); + foreach (var field in nodeData.Fields) + { + if (field.IsSkipped) + { + continue; + } + + if (field.IsOverride) + { + // The 'get' accessor is skipped for override fields + continue; + } + + // private static readonly Func FieldAccessor; + members = members.Add(SyntaxFactory.FieldDeclaration( + attributeLists: default, + modifiers: SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PrivateKeyword), SyntaxFactory.Token(SyntaxKind.StaticKeyword), SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword)), + declaration: SyntaxFactory.VariableDeclaration( + type: SyntaxFactory.GenericName( + identifier: SyntaxFactory.Identifier("Func"), + typeArgumentList: SyntaxFactory.TypeArgumentList(SyntaxFactory.SeparatedList( + new[] + { + SyntaxFactory.IdentifierName(concreteBase), + SyntaxFactory.ParseTypeName(field.GetAccessorResultType(syntaxData)), + }))), + variables: SyntaxFactory.SingletonSeparatedList(SyntaxFactory.VariableDeclarator(field.AccessorName))))); + } + + foreach (var field in nodeData.Fields) + { + if (field.IsSkipped) + { + continue; + } + + // private static readonly Func WithFieldAccessor; + members = members.Add(SyntaxFactory.FieldDeclaration( + attributeLists: default, + modifiers: SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PrivateKeyword), SyntaxFactory.Token(SyntaxKind.StaticKeyword), SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword)), + declaration: SyntaxFactory.VariableDeclaration( + type: SyntaxFactory.GenericName( + identifier: SyntaxFactory.Identifier("Func"), + typeArgumentList: SyntaxFactory.TypeArgumentList(SyntaxFactory.SeparatedList( + new[] + { + SyntaxFactory.IdentifierName(concreteBase), + SyntaxFactory.ParseTypeName(field.GetAccessorResultType(syntaxData)), + SyntaxFactory.IdentifierName(concreteBase), + }))), + variables: SyntaxFactory.SingletonSeparatedList(SyntaxFactory.VariableDeclarator(field.WithAccessorName))))); + } + // private SyntaxNodeWrapper(SyntaxNode node) // { // this.node = node; @@ -602,9 +655,9 @@ public SyntaxData(in GeneratorExecutionContext context, XDocument document) public ImmutableArray Nodes { get; } - public NodeData TryGetConcreteBase(NodeData node) + public NodeData TryGetConcreteType(NodeData node) { - for (var current = this.TryGetNode(node.BaseName); current is not null; current = this.TryGetNode(current.BaseName)) + for (var current = node; current is not null; current = this.TryGetNode(current.BaseName)) { if (current.WrapperName is null) { @@ -616,7 +669,12 @@ public NodeData TryGetConcreteBase(NodeData node) return null; } - private NodeData TryGetNode(string name) + public NodeData TryGetConcreteBase(NodeData node) + { + return this.TryGetConcreteType(this.TryGetNode(node.BaseName)); + } + + public NodeData TryGetNode(string name) { this.nameToNode.TryGetValue(name, out var node); return node; @@ -650,7 +708,7 @@ public NodeData(in GeneratorExecutionContext context, XElement element) } this.BaseName = element.Attribute("Base").Value; - this.Fields = element.XPathSelectElements("Field").Select(field => new FieldData(field)).ToImmutableArray(); + this.Fields = element.XPathSelectElements("descendant::Field").Select(field => new FieldData(field)).ToImmutableArray(); } public NodeKind Kind { get; } @@ -669,15 +727,52 @@ private sealed class FieldData public FieldData(XElement element) { this.Name = element.Attribute("Name").Value; - this.Type = element.Attribute("Type").Value; + + var type = element.Attribute("Type").Value; + this.Type = type switch + { + "SyntaxList" => nameof(SyntaxTokenList), + _ => type, + }; + this.IsOverride = element.Attribute("Override")?.Value == "true"; + + this.AccessorName = this.Name + "Accessor"; + this.WithAccessorName = "With" + this.Name + "Accessor"; } + public bool IsSkipped => false; + public string Name { get; } + public string AccessorName { get; } + + public string WithAccessorName { get; } + public string Type { get; } public bool IsOverride { get; } + + public string GetAccessorResultType(SyntaxData syntaxData) + { + var typeNode = syntaxData.TryGetNode(this.Type); + if (typeNode is not null) + { + return syntaxData.TryGetConcreteType(typeNode)?.Name ?? nameof(SyntaxNode); + } + + if (this.Type.StartsWith("SeparatedSyntaxList<") && this.Type.EndsWith(">")) + { + var elementTypeName = this.Type.Substring("SeparatedSyntaxList<".Length, this.Type.Length - "SeparatedSyntaxList<".Length - ">".Length); + var elementTypeNode = syntaxData.TryGetNode(elementTypeName); + if (elementTypeNode is { WrapperName: not null }) + { + return $"SeparatedSyntaxListWrapper<{elementTypeNode.WrapperName}>"; + } + } + + return this.Type; + } } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseObjectCreationExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseObjectCreationExpressionSyntaxWrapper.g.cs index 9bf854e7dc..68a39fd6c4 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseObjectCreationExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseObjectCreationExpressionSyntaxWrapper.g.cs @@ -14,6 +14,12 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax"; private static readonly Type WrappedType; private readonly ExpressionSyntax node; + private static readonly Func NewKeywordAccessor; + private static readonly Func ArgumentListAccessor; + private static readonly Func InitializerAccessor; + private static readonly Func WithNewKeywordAccessor; + private static readonly Func WithArgumentListAccessor; + private static readonly Func WithInitializerAccessor; private BaseObjectCreationExpressionSyntaxWrapper(ExpressionSyntax node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseParameterSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseParameterSyntaxWrapper.g.cs index f34b98dd7c..49fb191bee 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseParameterSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseParameterSyntaxWrapper.g.cs @@ -14,6 +14,12 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax"; private static readonly Type WrappedType; private readonly CSharpSyntaxNode node; + private static readonly Func> AttributeListsAccessor; + private static readonly Func ModifiersAccessor; + private static readonly Func TypeAccessor; + private static readonly Func, CSharpSyntaxNode> WithAttributeListsAccessor; + private static readonly Func WithModifiersAccessor; + private static readonly Func WithTypeAccessor; private BaseParameterSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BinaryPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BinaryPatternSyntaxWrapper.g.cs index 03cd04e216..4df06ed3c3 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BinaryPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BinaryPatternSyntaxWrapper.g.cs @@ -14,6 +14,12 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax"; private static readonly Type WrappedType; private readonly CSharpSyntaxNode node; + private static readonly Func LeftAccessor; + private static readonly Func OperatorTokenAccessor; + private static readonly Func RightAccessor; + private static readonly Func WithLeftAccessor; + private static readonly Func WithOperatorTokenAccessor; + private static readonly Func WithRightAccessor; private BinaryPatternSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CasePatternSwitchLabelSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CasePatternSwitchLabelSyntaxWrapper.g.cs index 2624d95e95..252405e31f 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CasePatternSwitchLabelSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CasePatternSwitchLabelSyntaxWrapper.g.cs @@ -14,6 +14,12 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax"; private static readonly Type WrappedType; private readonly SwitchLabelSyntax node; + private static readonly Func PatternAccessor; + private static readonly Func WhenClauseAccessor; + private static readonly Func WithKeywordAccessor; + private static readonly Func WithPatternAccessor; + private static readonly Func WithWhenClauseAccessor; + private static readonly Func WithColonTokenAccessor; private CasePatternSwitchLabelSyntaxWrapper(SwitchLabelSyntax node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CommonForEachStatementSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CommonForEachStatementSyntaxWrapper.g.cs index 7144baac92..785e818cd8 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CommonForEachStatementSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CommonForEachStatementSyntaxWrapper.g.cs @@ -14,6 +14,20 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax"; private static readonly Type WrappedType; private readonly StatementSyntax node; + private static readonly Func AwaitKeywordAccessor; + private static readonly Func ForEachKeywordAccessor; + private static readonly Func OpenParenTokenAccessor; + private static readonly Func InKeywordAccessor; + private static readonly Func ExpressionAccessor; + private static readonly Func CloseParenTokenAccessor; + private static readonly Func StatementAccessor; + private static readonly Func WithAwaitKeywordAccessor; + private static readonly Func WithForEachKeywordAccessor; + private static readonly Func WithOpenParenTokenAccessor; + private static readonly Func WithInKeywordAccessor; + private static readonly Func WithExpressionAccessor; + private static readonly Func WithCloseParenTokenAccessor; + private static readonly Func WithStatementAccessor; private CommonForEachStatementSyntaxWrapper(StatementSyntax node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ConstantPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ConstantPatternSyntaxWrapper.g.cs index b2aa8a0ada..25911e6501 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ConstantPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ConstantPatternSyntaxWrapper.g.cs @@ -14,6 +14,8 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax"; private static readonly Type WrappedType; private readonly CSharpSyntaxNode node; + private static readonly Func ExpressionAccessor; + private static readonly Func WithExpressionAccessor; private ConstantPatternSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationExpressionSyntaxWrapper.g.cs index 197e86df2c..891aa4fc0c 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationExpressionSyntaxWrapper.g.cs @@ -14,6 +14,10 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax"; private static readonly Type WrappedType; private readonly ExpressionSyntax node; + private static readonly Func TypeAccessor; + private static readonly Func DesignationAccessor; + private static readonly Func WithTypeAccessor; + private static readonly Func WithDesignationAccessor; private DeclarationExpressionSyntaxWrapper(ExpressionSyntax node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationPatternSyntaxWrapper.g.cs index 8fc39fa840..c8c4f7fad0 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationPatternSyntaxWrapper.g.cs @@ -14,6 +14,10 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax"; private static readonly Type WrappedType; private readonly CSharpSyntaxNode node; + private static readonly Func TypeAccessor; + private static readonly Func DesignationAccessor; + private static readonly Func WithTypeAccessor; + private static readonly Func WithDesignationAccessor; private DeclarationPatternSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DefaultConstraintSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DefaultConstraintSyntaxWrapper.g.cs index 315c46cea4..a9a7f83dc2 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DefaultConstraintSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DefaultConstraintSyntaxWrapper.g.cs @@ -14,6 +14,8 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax"; private static readonly Type WrappedType; private readonly TypeParameterConstraintSyntax node; + private static readonly Func DefaultKeywordAccessor; + private static readonly Func WithDefaultKeywordAccessor; private DefaultConstraintSyntaxWrapper(TypeParameterConstraintSyntax node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardDesignationSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardDesignationSyntaxWrapper.g.cs index 9e6c4e3e7a..daf02b98bc 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardDesignationSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardDesignationSyntaxWrapper.g.cs @@ -14,6 +14,8 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax"; private static readonly Type WrappedType; private readonly CSharpSyntaxNode node; + private static readonly Func UnderscoreTokenAccessor; + private static readonly Func WithUnderscoreTokenAccessor; private DiscardDesignationSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardPatternSyntaxWrapper.g.cs index a53f9a68d3..7cb526f604 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardPatternSyntaxWrapper.g.cs @@ -14,6 +14,8 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax"; private static readonly Type WrappedType; private readonly CSharpSyntaxNode node; + private static readonly Func UnderscoreTokenAccessor; + private static readonly Func WithUnderscoreTokenAccessor; private DiscardPatternSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ForEachVariableStatementSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ForEachVariableStatementSyntaxWrapper.g.cs index 267a5e3268..bc26f84b55 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ForEachVariableStatementSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ForEachVariableStatementSyntaxWrapper.g.cs @@ -14,6 +14,16 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax"; private static readonly Type WrappedType; private readonly StatementSyntax node; + private static readonly Func VariableAccessor; + private static readonly Func, StatementSyntax> WithAttributeListsAccessor; + private static readonly Func WithAwaitKeywordAccessor; + private static readonly Func WithForEachKeywordAccessor; + private static readonly Func WithOpenParenTokenAccessor; + private static readonly Func WithVariableAccessor; + private static readonly Func WithInKeywordAccessor; + private static readonly Func WithExpressionAccessor; + private static readonly Func WithCloseParenTokenAccessor; + private static readonly Func WithStatementAccessor; private ForEachVariableStatementSyntaxWrapper(StatementSyntax node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerCallingConventionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerCallingConventionSyntaxWrapper.g.cs index b1eb2feabf..139a637b85 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerCallingConventionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerCallingConventionSyntaxWrapper.g.cs @@ -14,6 +14,10 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax"; private static readonly Type WrappedType; private readonly CSharpSyntaxNode node; + private static readonly Func ManagedOrUnmanagedKeywordAccessor; + private static readonly Func UnmanagedCallingConventionListAccessor; + private static readonly Func WithManagedOrUnmanagedKeywordAccessor; + private static readonly Func WithUnmanagedCallingConventionListAccessor; private FunctionPointerCallingConventionSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterListSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterListSyntaxWrapper.g.cs index bb2409c892..28befbdef7 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterListSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterListSyntaxWrapper.g.cs @@ -14,6 +14,12 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax"; private static readonly Type WrappedType; private readonly CSharpSyntaxNode node; + private static readonly Func LessThanTokenAccessor; + private static readonly Func> ParametersAccessor; + private static readonly Func GreaterThanTokenAccessor; + private static readonly Func WithLessThanTokenAccessor; + private static readonly Func, CSharpSyntaxNode> WithParametersAccessor; + private static readonly Func WithGreaterThanTokenAccessor; private FunctionPointerParameterListSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterSyntaxWrapper.g.cs index 03a12af036..42ab3a6d7a 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterSyntaxWrapper.g.cs @@ -14,6 +14,9 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax"; private static readonly Type WrappedType; private readonly CSharpSyntaxNode node; + private static readonly Func, CSharpSyntaxNode> WithAttributeListsAccessor; + private static readonly Func WithModifiersAccessor; + private static readonly Func WithTypeAccessor; private FunctionPointerParameterSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerTypeSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerTypeSyntaxWrapper.g.cs index 428951982f..a4622a79c7 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerTypeSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerTypeSyntaxWrapper.g.cs @@ -14,6 +14,14 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax"; private static readonly Type WrappedType; private readonly TypeSyntax node; + private static readonly Func DelegateKeywordAccessor; + private static readonly Func AsteriskTokenAccessor; + private static readonly Func CallingConventionAccessor; + private static readonly Func ParameterListAccessor; + private static readonly Func WithDelegateKeywordAccessor; + private static readonly Func WithAsteriskTokenAccessor; + private static readonly Func WithCallingConventionAccessor; + private static readonly Func WithParameterListAccessor; private FunctionPointerTypeSyntaxWrapper(TypeSyntax node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionListSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionListSyntaxWrapper.g.cs index 72eea55811..d3bc2c8b04 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionListSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionListSyntaxWrapper.g.cs @@ -14,6 +14,12 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax"; private static readonly Type WrappedType; private readonly CSharpSyntaxNode node; + private static readonly Func OpenBracketTokenAccessor; + private static readonly Func> CallingConventionsAccessor; + private static readonly Func CloseBracketTokenAccessor; + private static readonly Func WithOpenBracketTokenAccessor; + private static readonly Func, CSharpSyntaxNode> WithCallingConventionsAccessor; + private static readonly Func WithCloseBracketTokenAccessor; private FunctionPointerUnmanagedCallingConventionListSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionSyntaxWrapper.g.cs index fb048aed9a..870e54f677 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionSyntaxWrapper.g.cs @@ -14,6 +14,8 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax"; private static readonly Type WrappedType; private readonly CSharpSyntaxNode node; + private static readonly Func NameAccessor; + private static readonly Func WithNameAccessor; private FunctionPointerUnmanagedCallingConventionSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitObjectCreationExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitObjectCreationExpressionSyntaxWrapper.g.cs index 263e5aa999..484304cb24 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitObjectCreationExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitObjectCreationExpressionSyntaxWrapper.g.cs @@ -14,6 +14,9 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax"; private static readonly Type WrappedType; private readonly ExpressionSyntax node; + private static readonly Func WithNewKeywordAccessor; + private static readonly Func WithArgumentListAccessor; + private static readonly Func WithInitializerAccessor; private ImplicitObjectCreationExpressionSyntaxWrapper(ExpressionSyntax node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.g.cs index 77ae08c74c..bf2ab55f1b 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.g.cs @@ -14,6 +14,14 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax"; private static readonly Type WrappedType; private readonly ExpressionSyntax node; + private static readonly Func StackAllocKeywordAccessor; + private static readonly Func OpenBracketTokenAccessor; + private static readonly Func CloseBracketTokenAccessor; + private static readonly Func InitializerAccessor; + private static readonly Func WithStackAllocKeywordAccessor; + private static readonly Func WithOpenBracketTokenAccessor; + private static readonly Func WithCloseBracketTokenAccessor; + private static readonly Func WithInitializerAccessor; private ImplicitStackAllocArrayCreationExpressionSyntaxWrapper(ExpressionSyntax node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/IsPatternExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/IsPatternExpressionSyntaxWrapper.g.cs index 305a0bfd47..42421c1d8c 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/IsPatternExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/IsPatternExpressionSyntaxWrapper.g.cs @@ -14,6 +14,12 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax"; private static readonly Type WrappedType; private readonly ExpressionSyntax node; + private static readonly Func ExpressionAccessor; + private static readonly Func IsKeywordAccessor; + private static readonly Func PatternAccessor; + private static readonly Func WithExpressionAccessor; + private static readonly Func WithIsKeywordAccessor; + private static readonly Func WithPatternAccessor; private IsPatternExpressionSyntaxWrapper(ExpressionSyntax node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/LocalFunctionStatementSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/LocalFunctionStatementSyntaxWrapper.g.cs index bfd916f669..9206188747 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/LocalFunctionStatementSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/LocalFunctionStatementSyntaxWrapper.g.cs @@ -14,6 +14,25 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax"; private static readonly Type WrappedType; private readonly StatementSyntax node; + private static readonly Func ModifiersAccessor; + private static readonly Func ReturnTypeAccessor; + private static readonly Func IdentifierAccessor; + private static readonly Func TypeParameterListAccessor; + private static readonly Func ParameterListAccessor; + private static readonly Func> ConstraintClausesAccessor; + private static readonly Func BodyAccessor; + private static readonly Func ExpressionBodyAccessor; + private static readonly Func SemicolonTokenAccessor; + private static readonly Func, StatementSyntax> WithAttributeListsAccessor; + private static readonly Func WithModifiersAccessor; + private static readonly Func WithReturnTypeAccessor; + private static readonly Func WithIdentifierAccessor; + private static readonly Func WithTypeParameterListAccessor; + private static readonly Func WithParameterListAccessor; + private static readonly Func, StatementSyntax> WithConstraintClausesAccessor; + private static readonly Func WithBodyAccessor; + private static readonly Func WithExpressionBodyAccessor; + private static readonly Func WithSemicolonTokenAccessor; private LocalFunctionStatementSyntaxWrapper(StatementSyntax node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/NullableDirectiveTriviaSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/NullableDirectiveTriviaSyntaxWrapper.g.cs index a1591757e5..5e5a20a63f 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/NullableDirectiveTriviaSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/NullableDirectiveTriviaSyntaxWrapper.g.cs @@ -14,6 +14,15 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax"; private static readonly Type WrappedType; private readonly DirectiveTriviaSyntax node; + private static readonly Func NullableKeywordAccessor; + private static readonly Func SettingTokenAccessor; + private static readonly Func TargetTokenAccessor; + private static readonly Func WithHashTokenAccessor; + private static readonly Func WithNullableKeywordAccessor; + private static readonly Func WithSettingTokenAccessor; + private static readonly Func WithTargetTokenAccessor; + private static readonly Func WithEndOfDirectiveTokenAccessor; + private static readonly Func WithIsActiveAccessor; private NullableDirectiveTriviaSyntaxWrapper(DirectiveTriviaSyntax node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedPatternSyntaxWrapper.g.cs index 5c809e7bab..6400f6eb33 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedPatternSyntaxWrapper.g.cs @@ -14,6 +14,12 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax"; private static readonly Type WrappedType; private readonly CSharpSyntaxNode node; + private static readonly Func OpenParenTokenAccessor; + private static readonly Func PatternAccessor; + private static readonly Func CloseParenTokenAccessor; + private static readonly Func WithOpenParenTokenAccessor; + private static readonly Func WithPatternAccessor; + private static readonly Func WithCloseParenTokenAccessor; private ParenthesizedPatternSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedVariableDesignationSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedVariableDesignationSyntaxWrapper.g.cs index c717e54f62..97e54c479f 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedVariableDesignationSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedVariableDesignationSyntaxWrapper.g.cs @@ -14,6 +14,12 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax"; private static readonly Type WrappedType; private readonly CSharpSyntaxNode node; + private static readonly Func OpenParenTokenAccessor; + private static readonly Func> VariablesAccessor; + private static readonly Func CloseParenTokenAccessor; + private static readonly Func WithOpenParenTokenAccessor; + private static readonly Func, CSharpSyntaxNode> WithVariablesAccessor; + private static readonly Func WithCloseParenTokenAccessor; private ParenthesizedVariableDesignationSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PositionalPatternClauseSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PositionalPatternClauseSyntaxWrapper.g.cs index 6a528fdbb2..768c8f07a4 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PositionalPatternClauseSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PositionalPatternClauseSyntaxWrapper.g.cs @@ -14,6 +14,12 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax"; private static readonly Type WrappedType; private readonly CSharpSyntaxNode node; + private static readonly Func OpenParenTokenAccessor; + private static readonly Func> SubpatternsAccessor; + private static readonly Func CloseParenTokenAccessor; + private static readonly Func WithOpenParenTokenAccessor; + private static readonly Func, CSharpSyntaxNode> WithSubpatternsAccessor; + private static readonly Func WithCloseParenTokenAccessor; private PositionalPatternClauseSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PrimaryConstructorBaseTypeSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PrimaryConstructorBaseTypeSyntaxWrapper.g.cs index b3274c8a35..cbfd97f17d 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PrimaryConstructorBaseTypeSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PrimaryConstructorBaseTypeSyntaxWrapper.g.cs @@ -14,6 +14,9 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax"; private static readonly Type WrappedType; private readonly BaseTypeSyntax node; + private static readonly Func ArgumentListAccessor; + private static readonly Func WithTypeAccessor; + private static readonly Func WithArgumentListAccessor; private PrimaryConstructorBaseTypeSyntaxWrapper(BaseTypeSyntax node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PropertyPatternClauseSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PropertyPatternClauseSyntaxWrapper.g.cs index e735c6d0b8..3901239e00 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PropertyPatternClauseSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PropertyPatternClauseSyntaxWrapper.g.cs @@ -14,6 +14,12 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax"; private static readonly Type WrappedType; private readonly CSharpSyntaxNode node; + private static readonly Func OpenBraceTokenAccessor; + private static readonly Func> SubpatternsAccessor; + private static readonly Func CloseBraceTokenAccessor; + private static readonly Func WithOpenBraceTokenAccessor; + private static readonly Func, CSharpSyntaxNode> WithSubpatternsAccessor; + private static readonly Func WithCloseBraceTokenAccessor; private PropertyPatternClauseSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RangeExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RangeExpressionSyntaxWrapper.g.cs index a650eb5fb7..a01707c949 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RangeExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RangeExpressionSyntaxWrapper.g.cs @@ -14,6 +14,12 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax"; private static readonly Type WrappedType; private readonly ExpressionSyntax node; + private static readonly Func LeftOperandAccessor; + private static readonly Func OperatorTokenAccessor; + private static readonly Func RightOperandAccessor; + private static readonly Func WithLeftOperandAccessor; + private static readonly Func WithOperatorTokenAccessor; + private static readonly Func WithRightOperandAccessor; private RangeExpressionSyntaxWrapper(ExpressionSyntax node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecordDeclarationSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecordDeclarationSyntaxWrapper.g.cs index 3a5fca6b42..b5b6d9d526 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecordDeclarationSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecordDeclarationSyntaxWrapper.g.cs @@ -14,6 +14,19 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax"; private static readonly Type WrappedType; private readonly TypeDeclarationSyntax node; + private static readonly Func ParameterListAccessor; + private static readonly Func, TypeDeclarationSyntax> WithAttributeListsAccessor; + private static readonly Func WithModifiersAccessor; + private static readonly Func WithKeywordAccessor; + private static readonly Func WithIdentifierAccessor; + private static readonly Func WithTypeParameterListAccessor; + private static readonly Func WithParameterListAccessor; + private static readonly Func WithBaseListAccessor; + private static readonly Func, TypeDeclarationSyntax> WithConstraintClausesAccessor; + private static readonly Func WithOpenBraceTokenAccessor; + private static readonly Func, TypeDeclarationSyntax> WithMembersAccessor; + private static readonly Func WithCloseBraceTokenAccessor; + private static readonly Func WithSemicolonTokenAccessor; private RecordDeclarationSyntaxWrapper(TypeDeclarationSyntax node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecursivePatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecursivePatternSyntaxWrapper.g.cs index c976a52c92..db780a0bd8 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecursivePatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecursivePatternSyntaxWrapper.g.cs @@ -14,6 +14,14 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax"; private static readonly Type WrappedType; private readonly CSharpSyntaxNode node; + private static readonly Func TypeAccessor; + private static readonly Func PositionalPatternClauseAccessor; + private static readonly Func PropertyPatternClauseAccessor; + private static readonly Func DesignationAccessor; + private static readonly Func WithTypeAccessor; + private static readonly Func WithPositionalPatternClauseAccessor; + private static readonly Func WithPropertyPatternClauseAccessor; + private static readonly Func WithDesignationAccessor; private RecursivePatternSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefExpressionSyntaxWrapper.g.cs index 8876ba600b..892222463e 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefExpressionSyntaxWrapper.g.cs @@ -14,6 +14,10 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax"; private static readonly Type WrappedType; private readonly ExpressionSyntax node; + private static readonly Func RefKeywordAccessor; + private static readonly Func ExpressionAccessor; + private static readonly Func WithRefKeywordAccessor; + private static readonly Func WithExpressionAccessor; private RefExpressionSyntaxWrapper(ExpressionSyntax node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefTypeSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefTypeSyntaxWrapper.g.cs index 3875b5831b..52edbf369c 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefTypeSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefTypeSyntaxWrapper.g.cs @@ -14,6 +14,12 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax"; private static readonly Type WrappedType; private readonly TypeSyntax node; + private static readonly Func RefKeywordAccessor; + private static readonly Func ReadOnlyKeywordAccessor; + private static readonly Func TypeAccessor; + private static readonly Func WithRefKeywordAccessor; + private static readonly Func WithReadOnlyKeywordAccessor; + private static readonly Func WithTypeAccessor; private RefTypeSyntaxWrapper(TypeSyntax node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RelationalPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RelationalPatternSyntaxWrapper.g.cs index 30b38b6040..0ef817d03d 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RelationalPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RelationalPatternSyntaxWrapper.g.cs @@ -14,6 +14,10 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax"; private static readonly Type WrappedType; private readonly CSharpSyntaxNode node; + private static readonly Func OperatorTokenAccessor; + private static readonly Func ExpressionAccessor; + private static readonly Func WithOperatorTokenAccessor; + private static readonly Func WithExpressionAccessor; private RelationalPatternSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SingleVariableDesignationSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SingleVariableDesignationSyntaxWrapper.g.cs index 928e550450..fd6c47f3fb 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SingleVariableDesignationSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SingleVariableDesignationSyntaxWrapper.g.cs @@ -14,6 +14,8 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax"; private static readonly Type WrappedType; private readonly CSharpSyntaxNode node; + private static readonly Func IdentifierAccessor; + private static readonly Func WithIdentifierAccessor; private SingleVariableDesignationSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SubpatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SubpatternSyntaxWrapper.g.cs index 4f7354e1c4..56f8d30ac8 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SubpatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SubpatternSyntaxWrapper.g.cs @@ -14,6 +14,10 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax"; private static readonly Type WrappedType; private readonly CSharpSyntaxNode node; + private static readonly Func NameColonAccessor; + private static readonly Func PatternAccessor; + private static readonly Func WithNameColonAccessor; + private static readonly Func WithPatternAccessor; private SubpatternSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionArmSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionArmSyntaxWrapper.g.cs index fd33975995..2069bb6a5e 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionArmSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionArmSyntaxWrapper.g.cs @@ -14,6 +14,14 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax"; private static readonly Type WrappedType; private readonly CSharpSyntaxNode node; + private static readonly Func PatternAccessor; + private static readonly Func WhenClauseAccessor; + private static readonly Func EqualsGreaterThanTokenAccessor; + private static readonly Func ExpressionAccessor; + private static readonly Func WithPatternAccessor; + private static readonly Func WithWhenClauseAccessor; + private static readonly Func WithEqualsGreaterThanTokenAccessor; + private static readonly Func WithExpressionAccessor; private SwitchExpressionArmSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionSyntaxWrapper.g.cs index 103d9ba983..78359a3c55 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionSyntaxWrapper.g.cs @@ -14,6 +14,16 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax"; private static readonly Type WrappedType; private readonly ExpressionSyntax node; + private static readonly Func GoverningExpressionAccessor; + private static readonly Func SwitchKeywordAccessor; + private static readonly Func OpenBraceTokenAccessor; + private static readonly Func> ArmsAccessor; + private static readonly Func CloseBraceTokenAccessor; + private static readonly Func WithGoverningExpressionAccessor; + private static readonly Func WithSwitchKeywordAccessor; + private static readonly Func WithOpenBraceTokenAccessor; + private static readonly Func, ExpressionSyntax> WithArmsAccessor; + private static readonly Func WithCloseBraceTokenAccessor; private SwitchExpressionSyntaxWrapper(ExpressionSyntax node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ThrowExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ThrowExpressionSyntaxWrapper.g.cs index 239f658b0a..1d0145f6e9 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ThrowExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ThrowExpressionSyntaxWrapper.g.cs @@ -14,6 +14,10 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax"; private static readonly Type WrappedType; private readonly ExpressionSyntax node; + private static readonly Func ThrowKeywordAccessor; + private static readonly Func ExpressionAccessor; + private static readonly Func WithThrowKeywordAccessor; + private static readonly Func WithExpressionAccessor; private ThrowExpressionSyntaxWrapper(ExpressionSyntax node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleElementSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleElementSyntaxWrapper.g.cs index 4d693ab107..f65145bd8f 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleElementSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleElementSyntaxWrapper.g.cs @@ -14,6 +14,10 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax"; private static readonly Type WrappedType; private readonly CSharpSyntaxNode node; + private static readonly Func TypeAccessor; + private static readonly Func IdentifierAccessor; + private static readonly Func WithTypeAccessor; + private static readonly Func WithIdentifierAccessor; private TupleElementSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleExpressionSyntaxWrapper.g.cs index 3ccbf7f1f5..caf997cd99 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleExpressionSyntaxWrapper.g.cs @@ -14,6 +14,12 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax"; private static readonly Type WrappedType; private readonly ExpressionSyntax node; + private static readonly Func OpenParenTokenAccessor; + private static readonly Func> ArgumentsAccessor; + private static readonly Func CloseParenTokenAccessor; + private static readonly Func WithOpenParenTokenAccessor; + private static readonly Func, ExpressionSyntax> WithArgumentsAccessor; + private static readonly Func WithCloseParenTokenAccessor; private TupleExpressionSyntaxWrapper(ExpressionSyntax node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleTypeSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleTypeSyntaxWrapper.g.cs index ea2c8f6dc0..73df8ad7d7 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleTypeSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleTypeSyntaxWrapper.g.cs @@ -14,6 +14,12 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax"; private static readonly Type WrappedType; private readonly TypeSyntax node; + private static readonly Func OpenParenTokenAccessor; + private static readonly Func> ElementsAccessor; + private static readonly Func CloseParenTokenAccessor; + private static readonly Func WithOpenParenTokenAccessor; + private static readonly Func, TypeSyntax> WithElementsAccessor; + private static readonly Func WithCloseParenTokenAccessor; private TupleTypeSyntaxWrapper(TypeSyntax node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TypePatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TypePatternSyntaxWrapper.g.cs index 05ba8ae5de..14041c21f5 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TypePatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TypePatternSyntaxWrapper.g.cs @@ -14,6 +14,8 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax"; private static readonly Type WrappedType; private readonly CSharpSyntaxNode node; + private static readonly Func TypeAccessor; + private static readonly Func WithTypeAccessor; private TypePatternSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/UnaryPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/UnaryPatternSyntaxWrapper.g.cs index 6da9ab7e92..eb06de7b2a 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/UnaryPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/UnaryPatternSyntaxWrapper.g.cs @@ -14,6 +14,10 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax"; private static readonly Type WrappedType; private readonly CSharpSyntaxNode node; + private static readonly Func OperatorTokenAccessor; + private static readonly Func PatternAccessor; + private static readonly Func WithOperatorTokenAccessor; + private static readonly Func WithPatternAccessor; private UnaryPatternSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VarPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VarPatternSyntaxWrapper.g.cs index eb34d1a3a7..b1dbbb68af 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VarPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VarPatternSyntaxWrapper.g.cs @@ -14,6 +14,10 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax"; private static readonly Type WrappedType; private readonly CSharpSyntaxNode node; + private static readonly Func VarKeywordAccessor; + private static readonly Func DesignationAccessor; + private static readonly Func WithVarKeywordAccessor; + private static readonly Func WithDesignationAccessor; private VarPatternSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WhenClauseSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WhenClauseSyntaxWrapper.g.cs index df1a4c144d..1896d4d7a0 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WhenClauseSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WhenClauseSyntaxWrapper.g.cs @@ -14,6 +14,10 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax"; private static readonly Type WrappedType; private readonly CSharpSyntaxNode node; + private static readonly Func WhenKeywordAccessor; + private static readonly Func ConditionAccessor; + private static readonly Func WithWhenKeywordAccessor; + private static readonly Func WithConditionAccessor; private WhenClauseSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WithExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WithExpressionSyntaxWrapper.g.cs index 35fbcfb5a1..16b71f78ea 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WithExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WithExpressionSyntaxWrapper.g.cs @@ -14,6 +14,12 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax"; private static readonly Type WrappedType; private readonly ExpressionSyntax node; + private static readonly Func ExpressionAccessor; + private static readonly Func WithKeywordAccessor; + private static readonly Func InitializerAccessor; + private static readonly Func WithExpressionAccessor; + private static readonly Func WithWithKeywordAccessor; + private static readonly Func WithInitializerAccessor; private WithExpressionSyntaxWrapper(ExpressionSyntax node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CasePatternSwitchLabelSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CasePatternSwitchLabelSyntaxWrapper.cs index 3fd041bf30..b7a82603e7 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CasePatternSwitchLabelSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CasePatternSwitchLabelSyntaxWrapper.cs @@ -3,20 +3,12 @@ namespace StyleCop.Analyzers.Lightup { - using System; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.CSharp.Syntax; internal partial struct CasePatternSwitchLabelSyntaxWrapper : ISyntaxWrapper { - private static readonly Func PatternAccessor; - private static readonly Func WhenClauseAccessor; - private static readonly Func WithKeywordAccessor; - private static readonly Func WithColonTokenAccessor; - private static readonly Func WithPatternAccessor; - private static readonly Func WithWhenClauseAccessor; - static CasePatternSwitchLabelSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(CasePatternSwitchLabelSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CommonForEachStatementSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CommonForEachStatementSyntaxWrapper.cs index 7423f1fe7b..26ba3ef671 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CommonForEachStatementSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CommonForEachStatementSyntaxWrapper.cs @@ -3,7 +3,6 @@ namespace StyleCop.Analyzers.Lightup { - using System; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp.Syntax; @@ -11,22 +10,6 @@ internal partial struct CommonForEachStatementSyntaxWrapper : ISyntaxWrapper AwaitKeywordAccessor; - private static readonly Func ForEachKeywordAccessor; - private static readonly Func OpenParenTokenAccessor; - private static readonly Func InKeywordAccessor; - private static readonly Func ExpressionAccessor; - private static readonly Func CloseParenTokenAccessor; - private static readonly Func StatementAccessor; - - private static readonly Func WithAwaitKeywordAccessor; - private static readonly Func WithForEachKeywordAccessor; - private static readonly Func WithOpenParenTokenAccessor; - private static readonly Func WithInKeywordAccessor; - private static readonly Func WithExpressionAccessor; - private static readonly Func WithCloseParenTokenAccessor; - private static readonly Func WithStatementAccessor; - static CommonForEachStatementSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(CommonForEachStatementSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ConstantPatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ConstantPatternSyntaxWrapper.cs index 9f2a5a750d..148382c908 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ConstantPatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ConstantPatternSyntaxWrapper.cs @@ -3,16 +3,11 @@ namespace StyleCop.Analyzers.Lightup { - using System; - using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.CSharp.Syntax; internal partial struct ConstantPatternSyntaxWrapper : ISyntaxWrapper { - private static readonly Func ExpressionAccessor; - private static readonly Func WithExpressionAccessor; - static ConstantPatternSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(ConstantPatternSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationExpressionSyntaxWrapper.cs index 02f7c6f970..0b7a281a16 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationExpressionSyntaxWrapper.cs @@ -3,18 +3,11 @@ namespace StyleCop.Analyzers.Lightup { - using System; - using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.CSharp.Syntax; internal partial struct DeclarationExpressionSyntaxWrapper : ISyntaxWrapper { - private static readonly Func TypeAccessor; - private static readonly Func DesignationAccessor; - private static readonly Func WithTypeAccessor; - private static readonly Func WithDesignationAccessor; - static DeclarationExpressionSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(DeclarationExpressionSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationPatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationPatternSyntaxWrapper.cs index 759a914d3e..49cbfbd8fb 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationPatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationPatternSyntaxWrapper.cs @@ -3,18 +3,11 @@ namespace StyleCop.Analyzers.Lightup { - using System; - using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.CSharp.Syntax; internal partial struct DeclarationPatternSyntaxWrapper : ISyntaxWrapper { - private static readonly Func TypeAccessor; - private static readonly Func DesignationAccessor; - private static readonly Func WithTypeAccessor; - private static readonly Func WithDesignationAccessor; - static DeclarationPatternSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(DeclarationPatternSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardDesignationSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardDesignationSyntaxWrapper.cs index 8b0585e886..d6000f65e4 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardDesignationSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardDesignationSyntaxWrapper.cs @@ -3,15 +3,11 @@ namespace StyleCop.Analyzers.Lightup { - using System; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; internal partial struct DiscardDesignationSyntaxWrapper : ISyntaxWrapper { - private static readonly Func UnderscoreTokenAccessor; - private static readonly Func WithUnderscoreTokenAccessor; - static DiscardDesignationSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(DiscardDesignationSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardPatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardPatternSyntaxWrapper.cs index bac3f84206..d74ab04aff 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardPatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardPatternSyntaxWrapper.cs @@ -3,15 +3,11 @@ namespace StyleCop.Analyzers.Lightup { - using System; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; internal partial struct DiscardPatternSyntaxWrapper : ISyntaxWrapper { - private static readonly Func UnderscoreTokenAccessor; - private static readonly Func WithUnderscoreTokenAccessor; - static DiscardPatternSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(DiscardPatternSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ForEachVariableStatementSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ForEachVariableStatementSyntaxWrapper.cs index 9bd90ae5bc..07edfdd5e0 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ForEachVariableStatementSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ForEachVariableStatementSyntaxWrapper.cs @@ -3,23 +3,11 @@ namespace StyleCop.Analyzers.Lightup { - using System; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp.Syntax; internal partial struct ForEachVariableStatementSyntaxWrapper : ISyntaxWrapper { - private static readonly Func VariableAccessor; - - private static readonly Func WithAwaitKeywordAccessor; - private static readonly Func WithForEachKeywordAccessor; - private static readonly Func WithOpenParenTokenAccessor; - private static readonly Func WithVariableAccessor; - private static readonly Func WithInKeywordAccessor; - private static readonly Func WithExpressionAccessor; - private static readonly Func WithCloseParenTokenAccessor; - private static readonly Func WithStatementAccessor; - static ForEachVariableStatementSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(ForEachVariableStatementSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.cs index 46bf4daac6..dc88c6ecb1 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.cs @@ -3,21 +3,11 @@ namespace StyleCop.Analyzers.Lightup { - using System; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp.Syntax; internal partial struct ImplicitStackAllocArrayCreationExpressionSyntaxWrapper : ISyntaxWrapper { - private static readonly Func StackAllocKeywordAccessor; - private static readonly Func OpenBracketTokenAccessor; - private static readonly Func CloseBracketTokenAccessor; - private static readonly Func InitializerAccessor; - private static readonly Func WithStackAllocKeywordAccessor; - private static readonly Func WithOpenBracketTokenAccessor; - private static readonly Func WithCloseBracketTokenAccessor; - private static readonly Func WithInitializerAccessor; - static ImplicitStackAllocArrayCreationExpressionSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(ImplicitStackAllocArrayCreationExpressionSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/IsPatternExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/IsPatternExpressionSyntaxWrapper.cs index c05f554ec2..e31bb1a85c 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/IsPatternExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/IsPatternExpressionSyntaxWrapper.cs @@ -3,20 +3,12 @@ namespace StyleCop.Analyzers.Lightup { - using System; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.CSharp.Syntax; internal partial struct IsPatternExpressionSyntaxWrapper : ISyntaxWrapper { - private static readonly Func ExpressionAccessor; - private static readonly Func IsKeywordAccessor; - private static readonly Func PatternAccessor; - private static readonly Func WithExpressionAccessor; - private static readonly Func WithIsKeywordAccessor; - private static readonly Func WithPatternAccessor; - static IsPatternExpressionSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(IsPatternExpressionSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/LocalFunctionStatementSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/LocalFunctionStatementSyntaxWrapper.cs index 94e06af962..380bb53df7 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/LocalFunctionStatementSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/LocalFunctionStatementSyntaxWrapper.cs @@ -3,32 +3,12 @@ namespace StyleCop.Analyzers.Lightup { - using System; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.CSharp.Syntax; internal partial struct LocalFunctionStatementSyntaxWrapper : ISyntaxWrapper { - private static readonly Func ModifiersAccessor; - private static readonly Func ReturnTypeAccessor; - private static readonly Func IdentifierAccessor; - private static readonly Func TypeParameterListAccessor; - private static readonly Func ParameterListAccessor; - private static readonly Func> ConstraintClausesAccessor; - private static readonly Func BodyAccessor; - private static readonly Func ExpressionBodyAccessor; - private static readonly Func SemicolonTokenAccessor; - private static readonly Func WithModifiersAccessor; - private static readonly Func WithReturnTypeAccessor; - private static readonly Func WithIdentifierAccessor; - private static readonly Func WithTypeParameterListAccessor; - private static readonly Func WithParameterListAccessor; - private static readonly Func, StatementSyntax> WithConstraintClausesAccessor; - private static readonly Func WithBodyAccessor; - private static readonly Func WithExpressionBodyAccessor; - private static readonly Func WithSemicolonTokenAccessor; - static LocalFunctionStatementSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(LocalFunctionStatementSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ParenthesizedVariableDesignationSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ParenthesizedVariableDesignationSyntaxWrapper.cs index 5911c66bfa..2470b392db 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ParenthesizedVariableDesignationSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ParenthesizedVariableDesignationSyntaxWrapper.cs @@ -3,19 +3,11 @@ namespace StyleCop.Analyzers.Lightup { - using System; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; internal partial struct ParenthesizedVariableDesignationSyntaxWrapper : ISyntaxWrapper { - private static readonly Func OpenParenTokenAccessor; - private static readonly Func> VariablesAccessor; - private static readonly Func CloseParenTokenAccessor; - private static readonly Func WithOpenParenTokenAccessor; - private static readonly Func, CSharpSyntaxNode> WithVariablesAccessor; - private static readonly Func WithCloseParenTokenAccessor; - static ParenthesizedVariableDesignationSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(ParenthesizedVariableDesignationSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PositionalPatternClauseSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PositionalPatternClauseSyntaxWrapper.cs index dd7e8693a5..9e6c6328f3 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PositionalPatternClauseSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PositionalPatternClauseSyntaxWrapper.cs @@ -3,20 +3,11 @@ namespace StyleCop.Analyzers.Lightup { - using System; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; internal partial struct PositionalPatternClauseSyntaxWrapper : ISyntaxWrapper { - private static readonly Func OpenParenTokenAccessor; - private static readonly Func> SubpatternsAccessor; - private static readonly Func CloseParenTokenAccessor; - - private static readonly Func WithOpenParenTokenAccessor; - private static readonly Func, CSharpSyntaxNode> WithSubpatternsAccessor; - private static readonly Func WithCloseParenTokenAccessor; - static PositionalPatternClauseSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(PositionalPatternClauseSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PropertyPatternClauseSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PropertyPatternClauseSyntaxWrapper.cs index 54898b16dc..097e6ba857 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PropertyPatternClauseSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PropertyPatternClauseSyntaxWrapper.cs @@ -3,20 +3,11 @@ namespace StyleCop.Analyzers.Lightup { - using System; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; internal partial struct PropertyPatternClauseSyntaxWrapper : ISyntaxWrapper { - private static readonly Func OpenBraceTokenAccessor; - private static readonly Func> SubpatternsAccessor; - private static readonly Func CloseBraceTokenAccessor; - - private static readonly Func WithOpenBraceTokenAccessor; - private static readonly Func, CSharpSyntaxNode> WithSubpatternsAccessor; - private static readonly Func WithCloseBraceTokenAccessor; - static PropertyPatternClauseSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(PropertyPatternClauseSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RangeExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RangeExpressionSyntaxWrapper.cs index 2debdd738f..cc1887cab6 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RangeExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RangeExpressionSyntaxWrapper.cs @@ -3,20 +3,11 @@ namespace StyleCop.Analyzers.Lightup { - using System; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp.Syntax; internal partial struct RangeExpressionSyntaxWrapper : ISyntaxWrapper { - private static readonly Func LeftOperandAccessor; - private static readonly Func OperatorTokenAccessor; - private static readonly Func RightOperandAccessor; - - private static readonly Func WithLeftOperandAccessor; - private static readonly Func WithOperatorTokenAccessor; - private static readonly Func WithRightOperandAccessor; - static RangeExpressionSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(RangeExpressionSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RecursivePatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RecursivePatternSyntaxWrapper.cs index 78c4dbe826..789c4fcbf8 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RecursivePatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RecursivePatternSyntaxWrapper.cs @@ -3,23 +3,11 @@ namespace StyleCop.Analyzers.Lightup { - using System; - using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.CSharp.Syntax; internal partial struct RecursivePatternSyntaxWrapper : ISyntaxWrapper { - private static readonly Func TypeAccessor; - private static readonly Func PositionalPatternClauseAccessor; - private static readonly Func PropertyPatternClauseAccessor; - private static readonly Func DesignationAccessor; - - private static readonly Func WithTypeAccessor; - private static readonly Func WithPositionalPatternClauseAccessor; - private static readonly Func WithPropertyPatternClauseAccessor; - private static readonly Func WithDesignationAccessor; - static RecursivePatternSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(RecursivePatternSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefExpressionSyntaxWrapper.cs index 8610b6903c..b53f09c65b 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefExpressionSyntaxWrapper.cs @@ -3,17 +3,11 @@ namespace StyleCop.Analyzers.Lightup { - using System; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp.Syntax; internal partial struct RefExpressionSyntaxWrapper : ISyntaxWrapper { - private static readonly Func RefKeywordAccessor; - private static readonly Func ExpressionAccessor; - private static readonly Func WithRefKeywordAccessor; - private static readonly Func WithExpressionAccessor; - static RefExpressionSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(RefExpressionSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefTypeSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefTypeSyntaxWrapper.cs index 1757928bfb..fbce0a3144 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefTypeSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefTypeSyntaxWrapper.cs @@ -3,19 +3,11 @@ namespace StyleCop.Analyzers.Lightup { - using System; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp.Syntax; internal partial struct RefTypeSyntaxWrapper : ISyntaxWrapper { - private static readonly Func RefKeywordAccessor; - private static readonly Func ReadOnlyKeywordAccessor; - private static readonly Func TypeAccessor; - private static readonly Func WithRefKeywordAccessor; - private static readonly Func WithReadOnlyKeywordAccessor; - private static readonly Func WithTypeAccessor; - static RefTypeSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(RefTypeSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SingleVariableDesignationSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SingleVariableDesignationSyntaxWrapper.cs index a30a36b980..d9dea90c2a 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SingleVariableDesignationSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SingleVariableDesignationSyntaxWrapper.cs @@ -3,15 +3,11 @@ namespace StyleCop.Analyzers.Lightup { - using System; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; internal partial struct SingleVariableDesignationSyntaxWrapper : ISyntaxWrapper { - private static readonly Func IdentifierAccessor; - private static readonly Func WithIdentifierAccessor; - static SingleVariableDesignationSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(SingleVariableDesignationSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SubpatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SubpatternSyntaxWrapper.cs index 70f0be3d9c..17ca4e87fb 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SubpatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SubpatternSyntaxWrapper.cs @@ -3,19 +3,11 @@ namespace StyleCop.Analyzers.Lightup { - using System; - using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.CSharp.Syntax; internal partial struct SubpatternSyntaxWrapper : ISyntaxWrapper { - private static readonly Func NameColonAccessor; - private static readonly Func PatternAccessor; - - private static readonly Func WithNameColonAccessor; - private static readonly Func WithPatternAccessor; - static SubpatternSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(SubpatternSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionArmSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionArmSyntaxWrapper.cs index 35d12572bf..6896b7b6c5 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionArmSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionArmSyntaxWrapper.cs @@ -3,23 +3,12 @@ namespace StyleCop.Analyzers.Lightup { - using System; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.CSharp.Syntax; internal partial struct SwitchExpressionArmSyntaxWrapper : ISyntaxWrapper { - private static readonly Func PatternAccessor; - private static readonly Func WhenClauseAccessor; - private static readonly Func ExpressionAccessor; - private static readonly Func EqualsGreaterThanTokenAccessor; - - private static readonly Func WithPatternAccessor; - private static readonly Func WithWhenClauseAccessor; - private static readonly Func WithExpressionAccessor; - private static readonly Func WithEqualsGreaterThanTokenAccessor; - static SwitchExpressionArmSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(SwitchExpressionArmSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionSyntaxWrapper.cs index 533e531557..556cb5fa5b 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionSyntaxWrapper.cs @@ -3,24 +3,11 @@ namespace StyleCop.Analyzers.Lightup { - using System; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp.Syntax; internal partial struct SwitchExpressionSyntaxWrapper : ISyntaxWrapper { - private static readonly Func> ArmsAccessor; - private static readonly Func GoverningExpressionAccessor; - private static readonly Func OpenBraceTokenAccessor; - private static readonly Func SwitchKeywordAccessor; - private static readonly Func CloseBraceTokenAccessor; - - private static readonly Func, ExpressionSyntax> WithArmsAccessor; - private static readonly Func WithGoverningExpressionAccessor; - private static readonly Func WithOpenBraceTokenAccessor; - private static readonly Func WithSwitchKeywordAccessor; - private static readonly Func WithCloseBraceTokenAccessor; - static SwitchExpressionSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(SwitchExpressionSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ThrowExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ThrowExpressionSyntaxWrapper.cs index ac64a5fc9c..8b150ad26e 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ThrowExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ThrowExpressionSyntaxWrapper.cs @@ -3,17 +3,11 @@ namespace StyleCop.Analyzers.Lightup { - using System; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp.Syntax; internal partial struct ThrowExpressionSyntaxWrapper : ISyntaxWrapper { - private static readonly Func ThrowKeywordAccessor; - private static readonly Func ExpressionAccessor; - private static readonly Func WithThrowKeywordAccessor; - private static readonly Func WithExpressionAccessor; - static ThrowExpressionSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(ThrowExpressionSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleElementSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleElementSyntaxWrapper.cs index 28274a7a1e..0513df695b 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleElementSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleElementSyntaxWrapper.cs @@ -3,18 +3,12 @@ namespace StyleCop.Analyzers.Lightup { - using System; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.CSharp.Syntax; internal partial struct TupleElementSyntaxWrapper : ISyntaxWrapper { - private static readonly Func IdentifierAccessor; - private static readonly Func TypeAccessor; - private static readonly Func WithIdentifierAccessor; - private static readonly Func WithTypeAccessor; - static TupleElementSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(TupleElementSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleExpressionSyntaxWrapper.cs index 98f95c6e00..97ffb59142 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleExpressionSyntaxWrapper.cs @@ -3,19 +3,11 @@ namespace StyleCop.Analyzers.Lightup { - using System; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp.Syntax; internal partial struct TupleExpressionSyntaxWrapper : ISyntaxWrapper { - private static readonly Func OpenParenTokenAccessor; - private static readonly Func> ArgumentsAccessor; - private static readonly Func CloseParenTokenAccessor; - private static readonly Func WithOpenParenTokenAccessor; - private static readonly Func, ExpressionSyntax> WithArgumentsAccessor; - private static readonly Func WithCloseParenTokenAccessor; - static TupleExpressionSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(TupleExpressionSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleTypeSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleTypeSyntaxWrapper.cs index b5f62909ed..ea93eba17f 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleTypeSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleTypeSyntaxWrapper.cs @@ -3,19 +3,11 @@ namespace StyleCop.Analyzers.Lightup { - using System; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp.Syntax; internal partial struct TupleTypeSyntaxWrapper : ISyntaxWrapper { - private static readonly Func OpenParenTokenAccessor; - private static readonly Func> ElementsAccessor; - private static readonly Func CloseParenTokenAccessor; - private static readonly Func WithOpenParenTokenAccessor; - private static readonly Func, TypeSyntax> WithElementsAccessor; - private static readonly Func WithCloseParenTokenAccessor; - static TupleTypeSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(TupleTypeSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VarPatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VarPatternSyntaxWrapper.cs index 7655fb6854..1e51d987ff 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VarPatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VarPatternSyntaxWrapper.cs @@ -3,18 +3,11 @@ namespace StyleCop.Analyzers.Lightup { - using System; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; internal partial struct VarPatternSyntaxWrapper : ISyntaxWrapper { - private static readonly Func VarKeywordAccessor; - private static readonly Func DesignationAccessor; - - private static readonly Func WithVarKeywordAccessor; - private static readonly Func WithDesignationAccessor; - static VarPatternSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(VarPatternSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/WhenClauseSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/WhenClauseSyntaxWrapper.cs index 1d00b6f0e0..918fbef4d1 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/WhenClauseSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/WhenClauseSyntaxWrapper.cs @@ -3,18 +3,12 @@ namespace StyleCop.Analyzers.Lightup { - using System; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.CSharp.Syntax; internal partial struct WhenClauseSyntaxWrapper : ISyntaxWrapper { - private static readonly Func WhenKeywordAccessor; - private static readonly Func ConditionAccessor; - private static readonly Func WithWhenKeywordAccessor; - private static readonly Func WithConditionAccessor; - static WhenClauseSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(WhenClauseSyntaxWrapper)); From 1bcc8647b01b05bb407f5490fd0761bbc4827e4c Mon Sep 17 00:00:00 2001 From: Sam Harwell Date: Mon, 16 Nov 2020 22:15:47 -0800 Subject: [PATCH 09/18] Enable nullable reference types --- .../OperationLightupGenerator.cs | 27 ++++++++++--------- .../StyleCop.Analyzers.CodeGeneration.csproj | 1 + .../SyntaxLightupGenerator.cs | 25 ++++++++++------- 3 files changed, 31 insertions(+), 22 deletions(-) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/OperationLightupGenerator.cs b/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/OperationLightupGenerator.cs index 98c9176bfc..7d9c9be26e 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/OperationLightupGenerator.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/OperationLightupGenerator.cs @@ -179,7 +179,8 @@ private void GenerateOperationInterface(in GeneratorExecutionContext context, In identifier: SyntaxFactory.Identifier(node.WrapperName), parameterList: SyntaxFactory.ParameterList(), initializer: null, - body: SyntaxFactory.Block(staticCtorStatements))); + body: SyntaxFactory.Block(staticCtorStatements), + expressionBody: null)); // private IArgumentOperationWrapper(IOperation operation) // { @@ -203,7 +204,8 @@ private void GenerateOperationInterface(in GeneratorExecutionContext context, In SyntaxKind.SimpleMemberAccessExpression, expression: SyntaxFactory.ThisExpression(), name: SyntaxFactory.IdentifierName("operation")), - right: SyntaxFactory.IdentifierName("operation")))))); + right: SyntaxFactory.IdentifierName("operation")))), + expressionBody: null)); // public IOperation WrappedOperation => this.operation; members = members.Add(SyntaxFactory.PropertyDeclaration( @@ -679,7 +681,8 @@ private void GenerateOperationWrapperHelper(in GeneratorExecutionContext context identifier: SyntaxFactory.Identifier("OperationWrapperHelper"), parameterList: SyntaxFactory.ParameterList(), initializer: null, - body: SyntaxFactory.Block(staticCtorStatements)); + body: SyntaxFactory.Block(staticCtorStatements), + expressionBody: null); // internal static Type GetWrappedType(Type wrapperType) // { @@ -831,7 +834,7 @@ public DocumentData(XDocument document) if (!operationKinds.TryGetValue(node.Attribute("Name").Value, out var kinds)) { - kinds = ImmutableArray<(string name, int value, string extraDescription)>.Empty; + kinds = ImmutableArray<(string name, int value, string? extraDescription)>.Empty; } var interfaceData = new InterfaceData(this, node, kinds); @@ -847,7 +850,7 @@ public DocumentData(XDocument document) if (!operationKinds.TryGetValue(node.Attribute("Name").Value, out var kinds)) { - kinds = ImmutableArray<(string name, int value, string extraDescription)>.Empty; + kinds = ImmutableArray<(string name, int value, string? extraDescription)>.Empty; } var interfaceData = new InterfaceData(this, node, kinds); @@ -859,11 +862,11 @@ public DocumentData(XDocument document) public ReadOnlyDictionary Interfaces { get; } - private static ImmutableDictionary> GetOperationKinds(XDocument document) + private static ImmutableDictionary> GetOperationKinds(XDocument document) { var skippedOperationKinds = GetSkippedOperationKinds(document); - var builder = ImmutableDictionary.CreateBuilder>(); + var builder = ImmutableDictionary.CreateBuilder>(); int operationKind = 0; foreach (var node in document.XPathSelectElements("/Tree/AbstractNode|/Tree/Node")) @@ -886,7 +889,7 @@ public DocumentData(XDocument document) } else if (explicitKind.XPathSelectElements("Entry").Any()) { - var nodeBuilder = ImmutableArray.CreateBuilder<(string name, int value, string extraDescription)>(); + var nodeBuilder = ImmutableArray.CreateBuilder<(string name, int value, string? extraDescription)>(); foreach (var entry in explicitKind.XPathSelectElements("Entry")) { if (entry.Attribute("EditorBrowsable")?.Value == "false") @@ -918,7 +921,7 @@ public DocumentData(XDocument document) var nodeName = node.Attribute("Name").Value; var kindName = nodeName.Substring("I".Length, nodeName.Length - "I".Length - "Operation".Length); - builder.Add(nodeName, ImmutableArray.Create((kindName, operationKind, (string)null))); + builder.Add(nodeName, ImmutableArray.Create((kindName, operationKind, (string?)null))); } return builder.ToImmutable(); @@ -955,7 +958,7 @@ private sealed class InterfaceData { private readonly DocumentData documentData; - public InterfaceData(DocumentData documentData, XElement node, ImmutableArray<(string name, int value, string extraDescription)> operationKinds) + public InterfaceData(DocumentData documentData, XElement node, ImmutableArray<(string name, int value, string? extraDescription)> operationKinds) { this.documentData = documentData; @@ -968,7 +971,7 @@ public InterfaceData(DocumentData documentData, XElement node, ImmutableArray<(s this.Properties = node.XPathSelectElements("Property").Select(property => new PropertyData(property)).ToImmutableArray(); } - public ImmutableArray<(string name, int value, string extraDescription)> OperationKinds { get; } + public ImmutableArray<(string name, int value, string? extraDescription)> OperationKinds { get; } public string InterfaceName { get; } @@ -982,7 +985,7 @@ public InterfaceData(DocumentData documentData, XElement node, ImmutableArray<(s public ImmutableArray Properties { get; } - public InterfaceData BaseInterface + public InterfaceData? BaseInterface { get { diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.csproj b/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.csproj index 53cf970df5..3e4872dad1 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.csproj +++ b/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.csproj @@ -3,6 +3,7 @@ netstandard2.0 + enable diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs b/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs index dd9c4826a9..ab5d52805d 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs @@ -48,15 +48,18 @@ private void GenerateSyntaxWrappers(in GeneratorExecutionContext context, Syntax { foreach (var node in syntaxData.Nodes) { - if (node.WrapperName is not null) - { - this.GenerateSyntaxWrapper(in context, syntaxData, node); - } + this.GenerateSyntaxWrapper(in context, syntaxData, node); } } private void GenerateSyntaxWrapper(in GeneratorExecutionContext context, SyntaxData syntaxData, NodeData nodeData) { + if (nodeData.WrapperName is null) + { + // No need to generate a wrapper for this type + return; + } + var concreteBase = syntaxData.TryGetConcreteBase(nodeData)?.Name ?? nameof(SyntaxNode); var members = SyntaxFactory.List(); @@ -163,7 +166,8 @@ private void GenerateSyntaxWrapper(in GeneratorExecutionContext context, SyntaxD SyntaxKind.SimpleMemberAccessExpression, expression: SyntaxFactory.ThisExpression(), name: SyntaxFactory.IdentifierName("node")), - right: SyntaxFactory.IdentifierName("node")))))); + right: SyntaxFactory.IdentifierName("node")))), + expressionBody: null)); // public SyntaxNode SyntaxNode => this.node; members = members.Add(SyntaxFactory.PropertyDeclaration( @@ -553,7 +557,8 @@ private void GenerateSyntaxWrapperHelper(in GeneratorExecutionContext context, I identifier: SyntaxFactory.Identifier("SyntaxWrapperHelper"), parameterList: SyntaxFactory.ParameterList(), initializer: null, - body: SyntaxFactory.Block(staticCtorStatements)); + body: SyntaxFactory.Block(staticCtorStatements), + expressionBody: null); // internal static Type GetWrappedType(Type wrapperType) // { @@ -655,7 +660,7 @@ public SyntaxData(in GeneratorExecutionContext context, XDocument document) public ImmutableArray Nodes { get; } - public NodeData TryGetConcreteType(NodeData node) + public NodeData? TryGetConcreteType(NodeData? node) { for (var current = node; current is not null; current = this.TryGetNode(current.BaseName)) { @@ -669,12 +674,12 @@ public NodeData TryGetConcreteType(NodeData node) return null; } - public NodeData TryGetConcreteBase(NodeData node) + public NodeData? TryGetConcreteBase(NodeData node) { return this.TryGetConcreteType(this.TryGetNode(node.BaseName)); } - public NodeData TryGetNode(string name) + public NodeData? TryGetNode(string name) { this.nameToNode.TryGetValue(name, out var node); return node; @@ -715,7 +720,7 @@ public NodeData(in GeneratorExecutionContext context, XElement element) public string Name { get; } - public string WrapperName { get; } + public string? WrapperName { get; } public string BaseName { get; } From 1ebaed92ad96ff1a8d2d8735ed71fd3661ffa611 Mon Sep 17 00:00:00 2001 From: Sam Harwell Date: Tue, 17 Nov 2020 06:23:43 -0800 Subject: [PATCH 10/18] Generate static constructors for syntax wrappers --- .../StyleCop.Analyzers.CodeGeneration.csproj | 2 + .../SyntaxLightupGenerator.cs | 216 +++++++++++++++++- ...ObjectCreationExpressionSyntaxWrapper.g.cs | 11 + .../BaseParameterSyntaxWrapper.g.cs | 11 + .../BinaryPatternSyntaxWrapper.g.cs | 11 + .../CasePatternSwitchLabelSyntaxWrapper.g.cs | 11 + .../CommonForEachStatementSyntaxWrapper.g.cs | 19 ++ .../ConstantPatternSyntaxWrapper.g.cs | 7 + .../DeclarationExpressionSyntaxWrapper.g.cs | 9 + .../DeclarationPatternSyntaxWrapper.g.cs | 9 + .../DefaultConstraintSyntaxWrapper.g.cs | 7 + .../DiscardDesignationSyntaxWrapper.g.cs | 7 + .../DiscardPatternSyntaxWrapper.g.cs | 7 + .../ExpressionOrPatternSyntaxWrapper.g.cs | 5 + ...ForEachVariableStatementSyntaxWrapper.g.cs | 15 ++ ...PointerCallingConventionSyntaxWrapper.g.cs | 9 + ...tionPointerParameterListSyntaxWrapper.g.cs | 11 + ...FunctionPointerParameterSyntaxWrapper.g.cs | 8 + .../FunctionPointerTypeSyntaxWrapper.g.cs | 13 ++ ...gedCallingConventionListSyntaxWrapper.g.cs | 11 + ...managedCallingConventionSyntaxWrapper.g.cs | 7 + ...ObjectCreationExpressionSyntaxWrapper.g.cs | 8 + ...cArrayCreationExpressionSyntaxWrapper.g.cs | 13 ++ .../IsPatternExpressionSyntaxWrapper.g.cs | 11 + .../LocalFunctionStatementSyntaxWrapper.g.cs | 24 ++ .../NullableDirectiveTriviaSyntaxWrapper.g.cs | 14 ++ .../ParenthesizedPatternSyntaxWrapper.g.cs | 11 + ...sizedVariableDesignationSyntaxWrapper.g.cs | 11 + .../PatternSyntaxWrapper.g.cs | 5 + .../PositionalPatternClauseSyntaxWrapper.g.cs | 11 + ...imaryConstructorBaseTypeSyntaxWrapper.g.cs | 8 + .../PropertyPatternClauseSyntaxWrapper.g.cs | 11 + .../RangeExpressionSyntaxWrapper.g.cs | 11 + .../RecordDeclarationSyntaxWrapper.g.cs | 18 ++ .../RecursivePatternSyntaxWrapper.g.cs | 13 ++ .../RefExpressionSyntaxWrapper.g.cs | 9 + .../RefTypeSyntaxWrapper.g.cs | 11 + .../RelationalPatternSyntaxWrapper.g.cs | 9 + ...ingleVariableDesignationSyntaxWrapper.g.cs | 7 + .../SubpatternSyntaxWrapper.g.cs | 9 + .../SwitchExpressionArmSyntaxWrapper.g.cs | 13 ++ .../SwitchExpressionSyntaxWrapper.g.cs | 15 ++ .../ThrowExpressionSyntaxWrapper.g.cs | 9 + .../TupleElementSyntaxWrapper.g.cs | 9 + .../TupleExpressionSyntaxWrapper.g.cs | 11 + .../TupleTypeSyntaxWrapper.g.cs | 11 + .../TypePatternSyntaxWrapper.g.cs | 7 + .../UnaryPatternSyntaxWrapper.g.cs | 9 + .../VarPatternSyntaxWrapper.g.cs | 9 + .../VariableDesignationSyntaxWrapper.g.cs | 5 + .../WhenClauseSyntaxWrapper.g.cs | 9 + .../WithExpressionSyntaxWrapper.g.cs | 11 + .../CasePatternSwitchLabelSyntaxWrapper.cs | 12 - .../CommonForEachStatementSyntaxWrapper.cs | 20 -- .../Lightup/ConstantPatternSyntaxWrapper.cs | 7 - .../DeclarationExpressionSyntaxWrapper.cs | 10 - .../DeclarationPatternSyntaxWrapper.cs | 9 - .../DiscardDesignationSyntaxWrapper.cs | 7 - .../Lightup/DiscardPatternSyntaxWrapper.cs | 7 - .../ForEachVariableStatementSyntaxWrapper.cs | 15 -- ...locArrayCreationExpressionSyntaxWrapper.cs | 13 -- .../IsPatternExpressionSyntaxWrapper.cs | 12 - .../LocalFunctionStatementSyntaxWrapper.cs | 23 -- ...hesizedVariableDesignationSyntaxWrapper.cs | 11 - .../Lightup/PatternSyntaxWrapper.cs | 15 -- .../PositionalPatternClauseSyntaxWrapper.cs | 12 - .../PropertyPatternClauseSyntaxWrapper.cs | 12 - .../Lightup/RangeExpressionSyntaxWrapper.cs | 12 - .../Lightup/RecursivePatternSyntaxWrapper.cs | 14 -- .../Lightup/RefExpressionSyntaxWrapper.cs | 9 - .../Lightup/RefTypeSyntaxWrapper.cs | 11 - .../SingleVariableDesignationSyntaxWrapper.cs | 7 - .../Lightup/SubpatternSyntaxWrapper.cs | 10 - .../SwitchExpressionArmSyntaxWrapper.cs | 14 -- .../Lightup/SwitchExpressionSyntaxWrapper.cs | 16 -- .../Lightup/ThrowExpressionSyntaxWrapper.cs | 9 - .../Lightup/TupleElementSyntaxWrapper.cs | 9 - .../Lightup/TupleExpressionSyntaxWrapper.cs | 11 - .../Lightup/TupleTypeSyntaxWrapper.cs | 11 - .../Lightup/VarPatternSyntaxWrapper.cs | 10 - .../VariableDesignationSyntaxWrapper.cs | 15 -- .../Lightup/WhenClauseSyntaxWrapper.cs | 9 - 82 files changed, 731 insertions(+), 359 deletions(-) delete mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PatternSyntaxWrapper.cs delete mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VariableDesignationSyntaxWrapper.cs diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.csproj b/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.csproj index 3e4872dad1..a4892d2cf3 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.csproj +++ b/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.csproj @@ -17,6 +17,8 @@ + + \ No newline at end of file diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs b/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs index ab5d52805d..6cc7b7003a 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs @@ -6,6 +6,8 @@ namespace StyleCop.Analyzers.CodeGeneration using System; using System.Collections.Generic; using System.Collections.Immutable; + using System.Diagnostics; + using System.Diagnostics.CodeAnalysis; using System.IO; using System.Linq; using System.Text; @@ -144,6 +146,146 @@ private void GenerateSyntaxWrapper(in GeneratorExecutionContext context, SyntaxD variables: SyntaxFactory.SingletonSeparatedList(SyntaxFactory.VariableDeclarator(field.WithAccessorName))))); } + // WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(SyntaxWrapper)); + var staticCtorStatements = SyntaxFactory.SingletonList( + SyntaxFactory.ExpressionStatement(SyntaxFactory.AssignmentExpression( + SyntaxKind.SimpleAssignmentExpression, + left: SyntaxFactory.IdentifierName("WrappedType"), + right: SyntaxFactory.InvocationExpression( + expression: SyntaxFactory.MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + expression: SyntaxFactory.IdentifierName("SyntaxWrapperHelper"), + name: SyntaxFactory.IdentifierName("GetWrappedType")), + argumentList: SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Argument( + SyntaxFactory.TypeOfExpression(SyntaxFactory.IdentifierName(nodeData.WrapperName))))))))); + + foreach (var field in nodeData.Fields) + { + if (field.IsSkipped) + { + continue; + } + + if (field.IsOverride) + { + // The 'get' accessor is skipped for override fields + continue; + } + + SimpleNameSyntax helperName; + if (field.IsWrappedSeparatedSyntaxList(syntaxData, out var elementNode)) + { + Debug.Assert(elementNode.WrapperName is not null, $"Assertion failed: {nameof(elementNode)}.{nameof(elementNode.WrapperName)} is not null"); + + // CreateSeparatedSyntaxListPropertyAccessor + helperName = SyntaxFactory.GenericName( + identifier: SyntaxFactory.Identifier("CreateSeparatedSyntaxListPropertyAccessor"), + typeArgumentList: SyntaxFactory.TypeArgumentList(SyntaxFactory.SeparatedList( + new[] + { + SyntaxFactory.IdentifierName(concreteBase), + SyntaxFactory.IdentifierName(elementNode.WrapperName), + }))); + } + else + { + // CreateSyntaxPropertyAccessor + helperName = SyntaxFactory.GenericName( + identifier: SyntaxFactory.Identifier("CreateSyntaxPropertyAccessor"), + typeArgumentList: SyntaxFactory.TypeArgumentList(SyntaxFactory.SeparatedList( + new[] + { + SyntaxFactory.IdentifierName(concreteBase), + SyntaxFactory.ParseTypeName(field.GetAccessorResultType(syntaxData)), + }))); + } + + // ReturnTypeAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(ReturnType)); + staticCtorStatements = staticCtorStatements.Add(SyntaxFactory.ExpressionStatement(SyntaxFactory.AssignmentExpression( + SyntaxKind.SimpleAssignmentExpression, + left: SyntaxFactory.IdentifierName(field.AccessorName), + right: SyntaxFactory.InvocationExpression( + expression: SyntaxFactory.MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + expression: SyntaxFactory.IdentifierName("LightupHelpers"), + name: helperName), + argumentList: SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList( + new[] + { + SyntaxFactory.Argument(SyntaxFactory.IdentifierName("WrappedType")), + SyntaxFactory.Argument(SyntaxFactory.InvocationExpression( + expression: SyntaxFactory.IdentifierName("nameof"), + argumentList: SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Argument(field.GetPropertyNameExpression(syntaxData)))))), + })))))); + } + + foreach (var field in nodeData.Fields) + { + if (field.IsSkipped) + { + continue; + } + + SimpleNameSyntax helperName; + if (field.IsWrappedSeparatedSyntaxList(syntaxData, out var elementNode)) + { + Debug.Assert(elementNode.WrapperName is not null, $"Assertion failed: {nameof(elementNode)}.{nameof(elementNode.WrapperName)} is not null"); + + // CreateSeparatedSyntaxListWithPropertyAccessor + helperName = SyntaxFactory.GenericName( + identifier: SyntaxFactory.Identifier("CreateSeparatedSyntaxListWithPropertyAccessor"), + typeArgumentList: SyntaxFactory.TypeArgumentList(SyntaxFactory.SeparatedList( + new[] + { + SyntaxFactory.IdentifierName(concreteBase), + SyntaxFactory.IdentifierName(elementNode.WrapperName), + }))); + } + else + { + // CreateSyntaxWithPropertyAccessor + helperName = SyntaxFactory.GenericName( + identifier: SyntaxFactory.Identifier("CreateSyntaxWithPropertyAccessor"), + typeArgumentList: SyntaxFactory.TypeArgumentList(SyntaxFactory.SeparatedList( + new[] + { + SyntaxFactory.IdentifierName(concreteBase), + SyntaxFactory.ParseTypeName(field.GetAccessorResultType(syntaxData)), + }))); + } + + // WithReturnTypeAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(ReturnType)); + staticCtorStatements = staticCtorStatements.Add(SyntaxFactory.ExpressionStatement(SyntaxFactory.AssignmentExpression( + SyntaxKind.SimpleAssignmentExpression, + left: SyntaxFactory.IdentifierName(field.WithAccessorName), + right: SyntaxFactory.InvocationExpression( + expression: SyntaxFactory.MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + expression: SyntaxFactory.IdentifierName("LightupHelpers"), + name: helperName), + argumentList: SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList( + new[] + { + SyntaxFactory.Argument(SyntaxFactory.IdentifierName("WrappedType")), + SyntaxFactory.Argument(SyntaxFactory.InvocationExpression( + expression: SyntaxFactory.IdentifierName("nameof"), + argumentList: SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Argument(field.GetPropertyNameExpression(syntaxData)))))), + })))))); + } + + // static SyntaxWrapper() + // { + // WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(SyntaxWrapper)); + // } + members = members.Add(SyntaxFactory.ConstructorDeclaration( + attributeLists: default, + modifiers: SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.StaticKeyword)), + identifier: SyntaxFactory.Identifier(nodeData.WrapperName), + parameterList: SyntaxFactory.ParameterList(), + initializer: null, + body: SyntaxFactory.Block(staticCtorStatements), + expressionBody: null)); + // private SyntaxNodeWrapper(SyntaxNode node) // { // this.node = node; @@ -713,7 +855,7 @@ public NodeData(in GeneratorExecutionContext context, XElement element) } this.BaseName = element.Attribute("Base").Value; - this.Fields = element.XPathSelectElements("descendant::Field").Select(field => new FieldData(field)).ToImmutableArray(); + this.Fields = element.XPathSelectElements("descendant::Field").Select(field => new FieldData(this, field)).ToImmutableArray(); } public NodeKind Kind { get; } @@ -725,12 +867,21 @@ public NodeData(in GeneratorExecutionContext context, XElement element) public string BaseName { get; } public ImmutableArray Fields { get; } + + internal FieldData? TryGetField(string name) + { + return this.Fields.SingleOrDefault(field => field.Name == name); + } } private sealed class FieldData { - public FieldData(XElement element) + private readonly NodeData nodeData; + + public FieldData(NodeData nodeData, XElement element) { + this.nodeData = nodeData; + this.Name = element.Attribute("Name").Value; var type = element.Attribute("Type").Value; @@ -758,26 +909,77 @@ public FieldData(XElement element) public bool IsOverride { get; } - public string GetAccessorResultType(SyntaxData syntaxData) + public NodeData GetDeclaringNode(SyntaxData syntaxData) { - var typeNode = syntaxData.TryGetNode(this.Type); - if (typeNode is not null) + for (var current = this.nodeData; current is not null; current = syntaxData.TryGetNode(current.BaseName)) { - return syntaxData.TryGetConcreteType(typeNode)?.Name ?? nameof(SyntaxNode); + var currentField = current.TryGetField(this.Name); + if (currentField is { IsOverride: false }) + { + return currentField.nodeData; + } } + throw new NotSupportedException("Unable to find declaring node."); + } + + public NameSyntax GetPropertyNameExpression(SyntaxData syntaxData) + { + var declaringNode = this.GetDeclaringNode(syntaxData); + if (declaringNode == this.nodeData) + { + return SyntaxFactory.IdentifierName(this.Name); + } + else + { + return SyntaxFactory.QualifiedName( + SyntaxFactory.IdentifierName(declaringNode.WrapperName ?? declaringNode.Name), + SyntaxFactory.IdentifierName(this.Name)); + } + } + + public bool IsWrappedSeparatedSyntaxList(SyntaxData syntaxData, [NotNullWhen(true)] out NodeData? element) + { if (this.Type.StartsWith("SeparatedSyntaxList<") && this.Type.EndsWith(">")) { var elementTypeName = this.Type.Substring("SeparatedSyntaxList<".Length, this.Type.Length - "SeparatedSyntaxList<".Length - ">".Length); var elementTypeNode = syntaxData.TryGetNode(elementTypeName); if (elementTypeNode is { WrapperName: not null }) { - return $"SeparatedSyntaxListWrapper<{elementTypeNode.WrapperName}>"; + element = elementTypeNode; + return true; } } + element = null; + return false; + } + + public string GetAccessorResultType(SyntaxData syntaxData) + { + var typeNode = syntaxData.TryGetNode(this.Type); + if (typeNode is not null) + { + return syntaxData.TryGetConcreteType(typeNode)?.Name ?? nameof(SyntaxNode); + } + + if (this.IsWrappedSeparatedSyntaxList(syntaxData, out var elementTypeNode)) + { + return $"SeparatedSyntaxListWrapper<{elementTypeNode.WrapperName}>"; + } + return this.Type; } + + public string? GetAccessorResultElementType(SyntaxData syntaxData) + { + if (this.IsWrappedSeparatedSyntaxList(syntaxData, out var elementTypeNode)) + { + return elementTypeNode.WrapperName; + } + + return null; + } } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseObjectCreationExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseObjectCreationExpressionSyntaxWrapper.g.cs index 68a39fd6c4..88371bb06d 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseObjectCreationExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseObjectCreationExpressionSyntaxWrapper.g.cs @@ -20,6 +20,17 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func WithNewKeywordAccessor; private static readonly Func WithArgumentListAccessor; private static readonly Func WithInitializerAccessor; + static BaseObjectCreationExpressionSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(BaseObjectCreationExpressionSyntaxWrapper)); + NewKeywordAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(NewKeyword)); + ArgumentListAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(ArgumentList)); + InitializerAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Initializer)); + WithNewKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(NewKeyword)); + WithArgumentListAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(ArgumentList)); + WithInitializerAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Initializer)); + } + private BaseObjectCreationExpressionSyntaxWrapper(ExpressionSyntax node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseParameterSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseParameterSyntaxWrapper.g.cs index 49fb191bee..579be994fa 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseParameterSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseParameterSyntaxWrapper.g.cs @@ -20,6 +20,17 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func, CSharpSyntaxNode> WithAttributeListsAccessor; private static readonly Func WithModifiersAccessor; private static readonly Func WithTypeAccessor; + static BaseParameterSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(BaseParameterSyntaxWrapper)); + AttributeListsAccessor = LightupHelpers.CreateSyntaxPropertyAccessor>(WrappedType, nameof(AttributeLists)); + ModifiersAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Modifiers)); + TypeAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Type)); + WithAttributeListsAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor>(WrappedType, nameof(AttributeLists)); + WithModifiersAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Modifiers)); + WithTypeAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Type)); + } + private BaseParameterSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BinaryPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BinaryPatternSyntaxWrapper.g.cs index 4df06ed3c3..b8fff84df7 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BinaryPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BinaryPatternSyntaxWrapper.g.cs @@ -20,6 +20,17 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func WithLeftAccessor; private static readonly Func WithOperatorTokenAccessor; private static readonly Func WithRightAccessor; + static BinaryPatternSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(BinaryPatternSyntaxWrapper)); + LeftAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Left)); + OperatorTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(OperatorToken)); + RightAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Right)); + WithLeftAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Left)); + WithOperatorTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(OperatorToken)); + WithRightAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Right)); + } + private BinaryPatternSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CasePatternSwitchLabelSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CasePatternSwitchLabelSyntaxWrapper.g.cs index 252405e31f..0c7c3a13c3 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CasePatternSwitchLabelSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CasePatternSwitchLabelSyntaxWrapper.g.cs @@ -20,6 +20,17 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func WithPatternAccessor; private static readonly Func WithWhenClauseAccessor; private static readonly Func WithColonTokenAccessor; + static CasePatternSwitchLabelSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(CasePatternSwitchLabelSyntaxWrapper)); + PatternAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Pattern)); + WhenClauseAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(WhenClause)); + WithKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(SwitchLabelSyntax.Keyword)); + WithPatternAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Pattern)); + WithWhenClauseAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(WhenClause)); + WithColonTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(SwitchLabelSyntax.ColonToken)); + } + private CasePatternSwitchLabelSyntaxWrapper(SwitchLabelSyntax node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CommonForEachStatementSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CommonForEachStatementSyntaxWrapper.g.cs index 785e818cd8..3c97ead6a9 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CommonForEachStatementSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CommonForEachStatementSyntaxWrapper.g.cs @@ -28,6 +28,25 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func WithExpressionAccessor; private static readonly Func WithCloseParenTokenAccessor; private static readonly Func WithStatementAccessor; + static CommonForEachStatementSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(CommonForEachStatementSyntaxWrapper)); + AwaitKeywordAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(AwaitKeyword)); + ForEachKeywordAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(ForEachKeyword)); + OpenParenTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(OpenParenToken)); + InKeywordAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(InKeyword)); + ExpressionAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Expression)); + CloseParenTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(CloseParenToken)); + StatementAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Statement)); + WithAwaitKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(AwaitKeyword)); + WithForEachKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(ForEachKeyword)); + WithOpenParenTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(OpenParenToken)); + WithInKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(InKeyword)); + WithExpressionAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Expression)); + WithCloseParenTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(CloseParenToken)); + WithStatementAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Statement)); + } + private CommonForEachStatementSyntaxWrapper(StatementSyntax node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ConstantPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ConstantPatternSyntaxWrapper.g.cs index 25911e6501..d861279a30 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ConstantPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ConstantPatternSyntaxWrapper.g.cs @@ -16,6 +16,13 @@ namespace StyleCop.Analyzers.Lightup private readonly CSharpSyntaxNode node; private static readonly Func ExpressionAccessor; private static readonly Func WithExpressionAccessor; + static ConstantPatternSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(ConstantPatternSyntaxWrapper)); + ExpressionAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Expression)); + WithExpressionAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Expression)); + } + private ConstantPatternSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationExpressionSyntaxWrapper.g.cs index 891aa4fc0c..a7135cc2cf 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationExpressionSyntaxWrapper.g.cs @@ -18,6 +18,15 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func DesignationAccessor; private static readonly Func WithTypeAccessor; private static readonly Func WithDesignationAccessor; + static DeclarationExpressionSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(DeclarationExpressionSyntaxWrapper)); + TypeAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Type)); + DesignationAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Designation)); + WithTypeAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Type)); + WithDesignationAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Designation)); + } + private DeclarationExpressionSyntaxWrapper(ExpressionSyntax node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationPatternSyntaxWrapper.g.cs index c8c4f7fad0..be1475f1e6 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationPatternSyntaxWrapper.g.cs @@ -18,6 +18,15 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func DesignationAccessor; private static readonly Func WithTypeAccessor; private static readonly Func WithDesignationAccessor; + static DeclarationPatternSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(DeclarationPatternSyntaxWrapper)); + TypeAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Type)); + DesignationAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Designation)); + WithTypeAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Type)); + WithDesignationAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Designation)); + } + private DeclarationPatternSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DefaultConstraintSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DefaultConstraintSyntaxWrapper.g.cs index a9a7f83dc2..9d3a16b1de 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DefaultConstraintSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DefaultConstraintSyntaxWrapper.g.cs @@ -16,6 +16,13 @@ namespace StyleCop.Analyzers.Lightup private readonly TypeParameterConstraintSyntax node; private static readonly Func DefaultKeywordAccessor; private static readonly Func WithDefaultKeywordAccessor; + static DefaultConstraintSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(DefaultConstraintSyntaxWrapper)); + DefaultKeywordAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(DefaultKeyword)); + WithDefaultKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(DefaultKeyword)); + } + private DefaultConstraintSyntaxWrapper(TypeParameterConstraintSyntax node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardDesignationSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardDesignationSyntaxWrapper.g.cs index daf02b98bc..49d7837bb6 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardDesignationSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardDesignationSyntaxWrapper.g.cs @@ -16,6 +16,13 @@ namespace StyleCop.Analyzers.Lightup private readonly CSharpSyntaxNode node; private static readonly Func UnderscoreTokenAccessor; private static readonly Func WithUnderscoreTokenAccessor; + static DiscardDesignationSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(DiscardDesignationSyntaxWrapper)); + UnderscoreTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(UnderscoreToken)); + WithUnderscoreTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(UnderscoreToken)); + } + private DiscardDesignationSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardPatternSyntaxWrapper.g.cs index 7cb526f604..61ba0ffa17 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardPatternSyntaxWrapper.g.cs @@ -16,6 +16,13 @@ namespace StyleCop.Analyzers.Lightup private readonly CSharpSyntaxNode node; private static readonly Func UnderscoreTokenAccessor; private static readonly Func WithUnderscoreTokenAccessor; + static DiscardPatternSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(DiscardPatternSyntaxWrapper)); + UnderscoreTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(UnderscoreToken)); + WithUnderscoreTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(UnderscoreToken)); + } + private DiscardPatternSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ExpressionOrPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ExpressionOrPatternSyntaxWrapper.g.cs index 2a1564ab58..24b6df8d96 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ExpressionOrPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ExpressionOrPatternSyntaxWrapper.g.cs @@ -14,6 +14,11 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionOrPatternSyntax"; private static readonly Type WrappedType; private readonly CSharpSyntaxNode node; + static ExpressionOrPatternSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(ExpressionOrPatternSyntaxWrapper)); + } + private ExpressionOrPatternSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ForEachVariableStatementSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ForEachVariableStatementSyntaxWrapper.g.cs index bc26f84b55..dabc1843e6 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ForEachVariableStatementSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ForEachVariableStatementSyntaxWrapper.g.cs @@ -24,6 +24,21 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func WithExpressionAccessor; private static readonly Func WithCloseParenTokenAccessor; private static readonly Func WithStatementAccessor; + static ForEachVariableStatementSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(ForEachVariableStatementSyntaxWrapper)); + VariableAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Variable)); + WithAttributeListsAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor>(WrappedType, nameof(StatementSyntax.AttributeLists)); + WithAwaitKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(CommonForEachStatementSyntaxWrapper.AwaitKeyword)); + WithForEachKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(CommonForEachStatementSyntaxWrapper.ForEachKeyword)); + WithOpenParenTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(CommonForEachStatementSyntaxWrapper.OpenParenToken)); + WithVariableAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Variable)); + WithInKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(CommonForEachStatementSyntaxWrapper.InKeyword)); + WithExpressionAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(CommonForEachStatementSyntaxWrapper.Expression)); + WithCloseParenTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(CommonForEachStatementSyntaxWrapper.CloseParenToken)); + WithStatementAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(CommonForEachStatementSyntaxWrapper.Statement)); + } + private ForEachVariableStatementSyntaxWrapper(StatementSyntax node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerCallingConventionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerCallingConventionSyntaxWrapper.g.cs index 139a637b85..3612717919 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerCallingConventionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerCallingConventionSyntaxWrapper.g.cs @@ -18,6 +18,15 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func UnmanagedCallingConventionListAccessor; private static readonly Func WithManagedOrUnmanagedKeywordAccessor; private static readonly Func WithUnmanagedCallingConventionListAccessor; + static FunctionPointerCallingConventionSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(FunctionPointerCallingConventionSyntaxWrapper)); + ManagedOrUnmanagedKeywordAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(ManagedOrUnmanagedKeyword)); + UnmanagedCallingConventionListAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(UnmanagedCallingConventionList)); + WithManagedOrUnmanagedKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(ManagedOrUnmanagedKeyword)); + WithUnmanagedCallingConventionListAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(UnmanagedCallingConventionList)); + } + private FunctionPointerCallingConventionSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterListSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterListSyntaxWrapper.g.cs index 28befbdef7..e7e869fd83 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterListSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterListSyntaxWrapper.g.cs @@ -20,6 +20,17 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func WithLessThanTokenAccessor; private static readonly Func, CSharpSyntaxNode> WithParametersAccessor; private static readonly Func WithGreaterThanTokenAccessor; + static FunctionPointerParameterListSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(FunctionPointerParameterListSyntaxWrapper)); + LessThanTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(LessThanToken)); + ParametersAccessor = LightupHelpers.CreateSeparatedSyntaxListPropertyAccessor(WrappedType, nameof(Parameters)); + GreaterThanTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(GreaterThanToken)); + WithLessThanTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(LessThanToken)); + WithParametersAccessor = LightupHelpers.CreateSeparatedSyntaxListWithPropertyAccessor(WrappedType, nameof(Parameters)); + WithGreaterThanTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(GreaterThanToken)); + } + private FunctionPointerParameterListSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterSyntaxWrapper.g.cs index 42ab3a6d7a..fb33495334 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterSyntaxWrapper.g.cs @@ -17,6 +17,14 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func, CSharpSyntaxNode> WithAttributeListsAccessor; private static readonly Func WithModifiersAccessor; private static readonly Func WithTypeAccessor; + static FunctionPointerParameterSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(FunctionPointerParameterSyntaxWrapper)); + WithAttributeListsAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor>(WrappedType, nameof(BaseParameterSyntaxWrapper.AttributeLists)); + WithModifiersAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(BaseParameterSyntaxWrapper.Modifiers)); + WithTypeAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(BaseParameterSyntaxWrapper.Type)); + } + private FunctionPointerParameterSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerTypeSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerTypeSyntaxWrapper.g.cs index a4622a79c7..df5d733c8b 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerTypeSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerTypeSyntaxWrapper.g.cs @@ -22,6 +22,19 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func WithAsteriskTokenAccessor; private static readonly Func WithCallingConventionAccessor; private static readonly Func WithParameterListAccessor; + static FunctionPointerTypeSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(FunctionPointerTypeSyntaxWrapper)); + DelegateKeywordAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(DelegateKeyword)); + AsteriskTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(AsteriskToken)); + CallingConventionAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(CallingConvention)); + ParameterListAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(ParameterList)); + WithDelegateKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(DelegateKeyword)); + WithAsteriskTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(AsteriskToken)); + WithCallingConventionAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(CallingConvention)); + WithParameterListAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(ParameterList)); + } + private FunctionPointerTypeSyntaxWrapper(TypeSyntax node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionListSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionListSyntaxWrapper.g.cs index d3bc2c8b04..2b4c2d7e8e 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionListSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionListSyntaxWrapper.g.cs @@ -20,6 +20,17 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func WithOpenBracketTokenAccessor; private static readonly Func, CSharpSyntaxNode> WithCallingConventionsAccessor; private static readonly Func WithCloseBracketTokenAccessor; + static FunctionPointerUnmanagedCallingConventionListSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(FunctionPointerUnmanagedCallingConventionListSyntaxWrapper)); + OpenBracketTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(OpenBracketToken)); + CallingConventionsAccessor = LightupHelpers.CreateSeparatedSyntaxListPropertyAccessor(WrappedType, nameof(CallingConventions)); + CloseBracketTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(CloseBracketToken)); + WithOpenBracketTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(OpenBracketToken)); + WithCallingConventionsAccessor = LightupHelpers.CreateSeparatedSyntaxListWithPropertyAccessor(WrappedType, nameof(CallingConventions)); + WithCloseBracketTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(CloseBracketToken)); + } + private FunctionPointerUnmanagedCallingConventionListSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionSyntaxWrapper.g.cs index 870e54f677..857c2792a7 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionSyntaxWrapper.g.cs @@ -16,6 +16,13 @@ namespace StyleCop.Analyzers.Lightup private readonly CSharpSyntaxNode node; private static readonly Func NameAccessor; private static readonly Func WithNameAccessor; + static FunctionPointerUnmanagedCallingConventionSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(FunctionPointerUnmanagedCallingConventionSyntaxWrapper)); + NameAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Name)); + WithNameAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Name)); + } + private FunctionPointerUnmanagedCallingConventionSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitObjectCreationExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitObjectCreationExpressionSyntaxWrapper.g.cs index 484304cb24..88184d42a6 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitObjectCreationExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitObjectCreationExpressionSyntaxWrapper.g.cs @@ -17,6 +17,14 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func WithNewKeywordAccessor; private static readonly Func WithArgumentListAccessor; private static readonly Func WithInitializerAccessor; + static ImplicitObjectCreationExpressionSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(ImplicitObjectCreationExpressionSyntaxWrapper)); + WithNewKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(BaseObjectCreationExpressionSyntaxWrapper.NewKeyword)); + WithArgumentListAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(BaseObjectCreationExpressionSyntaxWrapper.ArgumentList)); + WithInitializerAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(BaseObjectCreationExpressionSyntaxWrapper.Initializer)); + } + private ImplicitObjectCreationExpressionSyntaxWrapper(ExpressionSyntax node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.g.cs index bf2ab55f1b..a1c4e48a3d 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.g.cs @@ -22,6 +22,19 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func WithOpenBracketTokenAccessor; private static readonly Func WithCloseBracketTokenAccessor; private static readonly Func WithInitializerAccessor; + static ImplicitStackAllocArrayCreationExpressionSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(ImplicitStackAllocArrayCreationExpressionSyntaxWrapper)); + StackAllocKeywordAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(StackAllocKeyword)); + OpenBracketTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(OpenBracketToken)); + CloseBracketTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(CloseBracketToken)); + InitializerAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Initializer)); + WithStackAllocKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(StackAllocKeyword)); + WithOpenBracketTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(OpenBracketToken)); + WithCloseBracketTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(CloseBracketToken)); + WithInitializerAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Initializer)); + } + private ImplicitStackAllocArrayCreationExpressionSyntaxWrapper(ExpressionSyntax node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/IsPatternExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/IsPatternExpressionSyntaxWrapper.g.cs index 42421c1d8c..d0b2269435 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/IsPatternExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/IsPatternExpressionSyntaxWrapper.g.cs @@ -20,6 +20,17 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func WithExpressionAccessor; private static readonly Func WithIsKeywordAccessor; private static readonly Func WithPatternAccessor; + static IsPatternExpressionSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(IsPatternExpressionSyntaxWrapper)); + ExpressionAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Expression)); + IsKeywordAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(IsKeyword)); + PatternAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Pattern)); + WithExpressionAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Expression)); + WithIsKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(IsKeyword)); + WithPatternAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Pattern)); + } + private IsPatternExpressionSyntaxWrapper(ExpressionSyntax node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/LocalFunctionStatementSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/LocalFunctionStatementSyntaxWrapper.g.cs index 9206188747..35594d8eee 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/LocalFunctionStatementSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/LocalFunctionStatementSyntaxWrapper.g.cs @@ -33,6 +33,30 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func WithBodyAccessor; private static readonly Func WithExpressionBodyAccessor; private static readonly Func WithSemicolonTokenAccessor; + static LocalFunctionStatementSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(LocalFunctionStatementSyntaxWrapper)); + ModifiersAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Modifiers)); + ReturnTypeAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(ReturnType)); + IdentifierAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Identifier)); + TypeParameterListAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(TypeParameterList)); + ParameterListAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(ParameterList)); + ConstraintClausesAccessor = LightupHelpers.CreateSyntaxPropertyAccessor>(WrappedType, nameof(ConstraintClauses)); + BodyAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Body)); + ExpressionBodyAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(ExpressionBody)); + SemicolonTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(SemicolonToken)); + WithAttributeListsAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor>(WrappedType, nameof(StatementSyntax.AttributeLists)); + WithModifiersAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Modifiers)); + WithReturnTypeAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(ReturnType)); + WithIdentifierAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Identifier)); + WithTypeParameterListAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(TypeParameterList)); + WithParameterListAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(ParameterList)); + WithConstraintClausesAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor>(WrappedType, nameof(ConstraintClauses)); + WithBodyAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Body)); + WithExpressionBodyAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(ExpressionBody)); + WithSemicolonTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(SemicolonToken)); + } + private LocalFunctionStatementSyntaxWrapper(StatementSyntax node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/NullableDirectiveTriviaSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/NullableDirectiveTriviaSyntaxWrapper.g.cs index 5e5a20a63f..addd566f02 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/NullableDirectiveTriviaSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/NullableDirectiveTriviaSyntaxWrapper.g.cs @@ -23,6 +23,20 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func WithTargetTokenAccessor; private static readonly Func WithEndOfDirectiveTokenAccessor; private static readonly Func WithIsActiveAccessor; + static NullableDirectiveTriviaSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(NullableDirectiveTriviaSyntaxWrapper)); + NullableKeywordAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(NullableKeyword)); + SettingTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(SettingToken)); + TargetTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(TargetToken)); + WithHashTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(DirectiveTriviaSyntax.HashToken)); + WithNullableKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(NullableKeyword)); + WithSettingTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(SettingToken)); + WithTargetTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(TargetToken)); + WithEndOfDirectiveTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(DirectiveTriviaSyntax.EndOfDirectiveToken)); + WithIsActiveAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(DirectiveTriviaSyntax.IsActive)); + } + private NullableDirectiveTriviaSyntaxWrapper(DirectiveTriviaSyntax node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedPatternSyntaxWrapper.g.cs index 6400f6eb33..0e19a0fe46 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedPatternSyntaxWrapper.g.cs @@ -20,6 +20,17 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func WithOpenParenTokenAccessor; private static readonly Func WithPatternAccessor; private static readonly Func WithCloseParenTokenAccessor; + static ParenthesizedPatternSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(ParenthesizedPatternSyntaxWrapper)); + OpenParenTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(OpenParenToken)); + PatternAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Pattern)); + CloseParenTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(CloseParenToken)); + WithOpenParenTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(OpenParenToken)); + WithPatternAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Pattern)); + WithCloseParenTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(CloseParenToken)); + } + private ParenthesizedPatternSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedVariableDesignationSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedVariableDesignationSyntaxWrapper.g.cs index 97e54c479f..00878dd435 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedVariableDesignationSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedVariableDesignationSyntaxWrapper.g.cs @@ -20,6 +20,17 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func WithOpenParenTokenAccessor; private static readonly Func, CSharpSyntaxNode> WithVariablesAccessor; private static readonly Func WithCloseParenTokenAccessor; + static ParenthesizedVariableDesignationSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(ParenthesizedVariableDesignationSyntaxWrapper)); + OpenParenTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(OpenParenToken)); + VariablesAccessor = LightupHelpers.CreateSeparatedSyntaxListPropertyAccessor(WrappedType, nameof(Variables)); + CloseParenTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(CloseParenToken)); + WithOpenParenTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(OpenParenToken)); + WithVariablesAccessor = LightupHelpers.CreateSeparatedSyntaxListWithPropertyAccessor(WrappedType, nameof(Variables)); + WithCloseParenTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(CloseParenToken)); + } + private ParenthesizedVariableDesignationSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PatternSyntaxWrapper.g.cs index 4b2104546a..16c5a45eec 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PatternSyntaxWrapper.g.cs @@ -14,6 +14,11 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax"; private static readonly Type WrappedType; private readonly CSharpSyntaxNode node; + static PatternSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(PatternSyntaxWrapper)); + } + private PatternSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PositionalPatternClauseSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PositionalPatternClauseSyntaxWrapper.g.cs index 768c8f07a4..44f4b2f3f8 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PositionalPatternClauseSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PositionalPatternClauseSyntaxWrapper.g.cs @@ -20,6 +20,17 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func WithOpenParenTokenAccessor; private static readonly Func, CSharpSyntaxNode> WithSubpatternsAccessor; private static readonly Func WithCloseParenTokenAccessor; + static PositionalPatternClauseSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(PositionalPatternClauseSyntaxWrapper)); + OpenParenTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(OpenParenToken)); + SubpatternsAccessor = LightupHelpers.CreateSeparatedSyntaxListPropertyAccessor(WrappedType, nameof(Subpatterns)); + CloseParenTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(CloseParenToken)); + WithOpenParenTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(OpenParenToken)); + WithSubpatternsAccessor = LightupHelpers.CreateSeparatedSyntaxListWithPropertyAccessor(WrappedType, nameof(Subpatterns)); + WithCloseParenTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(CloseParenToken)); + } + private PositionalPatternClauseSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PrimaryConstructorBaseTypeSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PrimaryConstructorBaseTypeSyntaxWrapper.g.cs index cbfd97f17d..8a3312e9aa 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PrimaryConstructorBaseTypeSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PrimaryConstructorBaseTypeSyntaxWrapper.g.cs @@ -17,6 +17,14 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func ArgumentListAccessor; private static readonly Func WithTypeAccessor; private static readonly Func WithArgumentListAccessor; + static PrimaryConstructorBaseTypeSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(PrimaryConstructorBaseTypeSyntaxWrapper)); + ArgumentListAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(ArgumentList)); + WithTypeAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(BaseTypeSyntax.Type)); + WithArgumentListAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(ArgumentList)); + } + private PrimaryConstructorBaseTypeSyntaxWrapper(BaseTypeSyntax node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PropertyPatternClauseSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PropertyPatternClauseSyntaxWrapper.g.cs index 3901239e00..1ea74d0dfa 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PropertyPatternClauseSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PropertyPatternClauseSyntaxWrapper.g.cs @@ -20,6 +20,17 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func WithOpenBraceTokenAccessor; private static readonly Func, CSharpSyntaxNode> WithSubpatternsAccessor; private static readonly Func WithCloseBraceTokenAccessor; + static PropertyPatternClauseSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(PropertyPatternClauseSyntaxWrapper)); + OpenBraceTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(OpenBraceToken)); + SubpatternsAccessor = LightupHelpers.CreateSeparatedSyntaxListPropertyAccessor(WrappedType, nameof(Subpatterns)); + CloseBraceTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(CloseBraceToken)); + WithOpenBraceTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(OpenBraceToken)); + WithSubpatternsAccessor = LightupHelpers.CreateSeparatedSyntaxListWithPropertyAccessor(WrappedType, nameof(Subpatterns)); + WithCloseBraceTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(CloseBraceToken)); + } + private PropertyPatternClauseSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RangeExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RangeExpressionSyntaxWrapper.g.cs index a01707c949..9dfb9fc5b4 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RangeExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RangeExpressionSyntaxWrapper.g.cs @@ -20,6 +20,17 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func WithLeftOperandAccessor; private static readonly Func WithOperatorTokenAccessor; private static readonly Func WithRightOperandAccessor; + static RangeExpressionSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(RangeExpressionSyntaxWrapper)); + LeftOperandAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(LeftOperand)); + OperatorTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(OperatorToken)); + RightOperandAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(RightOperand)); + WithLeftOperandAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(LeftOperand)); + WithOperatorTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(OperatorToken)); + WithRightOperandAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(RightOperand)); + } + private RangeExpressionSyntaxWrapper(ExpressionSyntax node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecordDeclarationSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecordDeclarationSyntaxWrapper.g.cs index b5b6d9d526..88ea5b850f 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecordDeclarationSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecordDeclarationSyntaxWrapper.g.cs @@ -27,6 +27,24 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func, TypeDeclarationSyntax> WithMembersAccessor; private static readonly Func WithCloseBraceTokenAccessor; private static readonly Func WithSemicolonTokenAccessor; + static RecordDeclarationSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(RecordDeclarationSyntaxWrapper)); + ParameterListAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(ParameterList)); + WithAttributeListsAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor>(WrappedType, nameof(MemberDeclarationSyntax.AttributeLists)); + WithModifiersAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(MemberDeclarationSyntax.Modifiers)); + WithKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(TypeDeclarationSyntax.Keyword)); + WithIdentifierAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(BaseTypeDeclarationSyntax.Identifier)); + WithTypeParameterListAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(TypeDeclarationSyntax.TypeParameterList)); + WithParameterListAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(ParameterList)); + WithBaseListAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(BaseTypeDeclarationSyntax.BaseList)); + WithConstraintClausesAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor>(WrappedType, nameof(TypeDeclarationSyntax.ConstraintClauses)); + WithOpenBraceTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(BaseTypeDeclarationSyntax.OpenBraceToken)); + WithMembersAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor>(WrappedType, nameof(TypeDeclarationSyntax.Members)); + WithCloseBraceTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(BaseTypeDeclarationSyntax.CloseBraceToken)); + WithSemicolonTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(BaseTypeDeclarationSyntax.SemicolonToken)); + } + private RecordDeclarationSyntaxWrapper(TypeDeclarationSyntax node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecursivePatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecursivePatternSyntaxWrapper.g.cs index db780a0bd8..6e9fd8c130 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecursivePatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecursivePatternSyntaxWrapper.g.cs @@ -22,6 +22,19 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func WithPositionalPatternClauseAccessor; private static readonly Func WithPropertyPatternClauseAccessor; private static readonly Func WithDesignationAccessor; + static RecursivePatternSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(RecursivePatternSyntaxWrapper)); + TypeAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Type)); + PositionalPatternClauseAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(PositionalPatternClause)); + PropertyPatternClauseAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(PropertyPatternClause)); + DesignationAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Designation)); + WithTypeAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Type)); + WithPositionalPatternClauseAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(PositionalPatternClause)); + WithPropertyPatternClauseAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(PropertyPatternClause)); + WithDesignationAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Designation)); + } + private RecursivePatternSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefExpressionSyntaxWrapper.g.cs index 892222463e..78b2acd0d6 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefExpressionSyntaxWrapper.g.cs @@ -18,6 +18,15 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func ExpressionAccessor; private static readonly Func WithRefKeywordAccessor; private static readonly Func WithExpressionAccessor; + static RefExpressionSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(RefExpressionSyntaxWrapper)); + RefKeywordAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(RefKeyword)); + ExpressionAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Expression)); + WithRefKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(RefKeyword)); + WithExpressionAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Expression)); + } + private RefExpressionSyntaxWrapper(ExpressionSyntax node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefTypeSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefTypeSyntaxWrapper.g.cs index 52edbf369c..ebb331b9ad 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefTypeSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefTypeSyntaxWrapper.g.cs @@ -20,6 +20,17 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func WithRefKeywordAccessor; private static readonly Func WithReadOnlyKeywordAccessor; private static readonly Func WithTypeAccessor; + static RefTypeSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(RefTypeSyntaxWrapper)); + RefKeywordAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(RefKeyword)); + ReadOnlyKeywordAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(ReadOnlyKeyword)); + TypeAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Type)); + WithRefKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(RefKeyword)); + WithReadOnlyKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(ReadOnlyKeyword)); + WithTypeAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Type)); + } + private RefTypeSyntaxWrapper(TypeSyntax node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RelationalPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RelationalPatternSyntaxWrapper.g.cs index 0ef817d03d..9cf5c08980 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RelationalPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RelationalPatternSyntaxWrapper.g.cs @@ -18,6 +18,15 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func ExpressionAccessor; private static readonly Func WithOperatorTokenAccessor; private static readonly Func WithExpressionAccessor; + static RelationalPatternSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(RelationalPatternSyntaxWrapper)); + OperatorTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(OperatorToken)); + ExpressionAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Expression)); + WithOperatorTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(OperatorToken)); + WithExpressionAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Expression)); + } + private RelationalPatternSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SingleVariableDesignationSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SingleVariableDesignationSyntaxWrapper.g.cs index fd6c47f3fb..b52911956a 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SingleVariableDesignationSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SingleVariableDesignationSyntaxWrapper.g.cs @@ -16,6 +16,13 @@ namespace StyleCop.Analyzers.Lightup private readonly CSharpSyntaxNode node; private static readonly Func IdentifierAccessor; private static readonly Func WithIdentifierAccessor; + static SingleVariableDesignationSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(SingleVariableDesignationSyntaxWrapper)); + IdentifierAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Identifier)); + WithIdentifierAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Identifier)); + } + private SingleVariableDesignationSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SubpatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SubpatternSyntaxWrapper.g.cs index 56f8d30ac8..2b28f59bba 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SubpatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SubpatternSyntaxWrapper.g.cs @@ -18,6 +18,15 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func PatternAccessor; private static readonly Func WithNameColonAccessor; private static readonly Func WithPatternAccessor; + static SubpatternSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(SubpatternSyntaxWrapper)); + NameColonAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(NameColon)); + PatternAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Pattern)); + WithNameColonAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(NameColon)); + WithPatternAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Pattern)); + } + private SubpatternSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionArmSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionArmSyntaxWrapper.g.cs index 2069bb6a5e..3cf390649e 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionArmSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionArmSyntaxWrapper.g.cs @@ -22,6 +22,19 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func WithWhenClauseAccessor; private static readonly Func WithEqualsGreaterThanTokenAccessor; private static readonly Func WithExpressionAccessor; + static SwitchExpressionArmSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(SwitchExpressionArmSyntaxWrapper)); + PatternAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Pattern)); + WhenClauseAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(WhenClause)); + EqualsGreaterThanTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(EqualsGreaterThanToken)); + ExpressionAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Expression)); + WithPatternAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Pattern)); + WithWhenClauseAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(WhenClause)); + WithEqualsGreaterThanTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(EqualsGreaterThanToken)); + WithExpressionAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Expression)); + } + private SwitchExpressionArmSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionSyntaxWrapper.g.cs index 78359a3c55..13d34a09f6 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionSyntaxWrapper.g.cs @@ -24,6 +24,21 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func WithOpenBraceTokenAccessor; private static readonly Func, ExpressionSyntax> WithArmsAccessor; private static readonly Func WithCloseBraceTokenAccessor; + static SwitchExpressionSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(SwitchExpressionSyntaxWrapper)); + GoverningExpressionAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(GoverningExpression)); + SwitchKeywordAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(SwitchKeyword)); + OpenBraceTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(OpenBraceToken)); + ArmsAccessor = LightupHelpers.CreateSeparatedSyntaxListPropertyAccessor(WrappedType, nameof(Arms)); + CloseBraceTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(CloseBraceToken)); + WithGoverningExpressionAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(GoverningExpression)); + WithSwitchKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(SwitchKeyword)); + WithOpenBraceTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(OpenBraceToken)); + WithArmsAccessor = LightupHelpers.CreateSeparatedSyntaxListWithPropertyAccessor(WrappedType, nameof(Arms)); + WithCloseBraceTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(CloseBraceToken)); + } + private SwitchExpressionSyntaxWrapper(ExpressionSyntax node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ThrowExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ThrowExpressionSyntaxWrapper.g.cs index 1d0145f6e9..51197e5c19 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ThrowExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ThrowExpressionSyntaxWrapper.g.cs @@ -18,6 +18,15 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func ExpressionAccessor; private static readonly Func WithThrowKeywordAccessor; private static readonly Func WithExpressionAccessor; + static ThrowExpressionSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(ThrowExpressionSyntaxWrapper)); + ThrowKeywordAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(ThrowKeyword)); + ExpressionAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Expression)); + WithThrowKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(ThrowKeyword)); + WithExpressionAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Expression)); + } + private ThrowExpressionSyntaxWrapper(ExpressionSyntax node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleElementSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleElementSyntaxWrapper.g.cs index f65145bd8f..65fc6e11ff 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleElementSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleElementSyntaxWrapper.g.cs @@ -18,6 +18,15 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func IdentifierAccessor; private static readonly Func WithTypeAccessor; private static readonly Func WithIdentifierAccessor; + static TupleElementSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(TupleElementSyntaxWrapper)); + TypeAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Type)); + IdentifierAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Identifier)); + WithTypeAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Type)); + WithIdentifierAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Identifier)); + } + private TupleElementSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleExpressionSyntaxWrapper.g.cs index caf997cd99..026b0c5953 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleExpressionSyntaxWrapper.g.cs @@ -20,6 +20,17 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func WithOpenParenTokenAccessor; private static readonly Func, ExpressionSyntax> WithArgumentsAccessor; private static readonly Func WithCloseParenTokenAccessor; + static TupleExpressionSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(TupleExpressionSyntaxWrapper)); + OpenParenTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(OpenParenToken)); + ArgumentsAccessor = LightupHelpers.CreateSyntaxPropertyAccessor>(WrappedType, nameof(Arguments)); + CloseParenTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(CloseParenToken)); + WithOpenParenTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(OpenParenToken)); + WithArgumentsAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor>(WrappedType, nameof(Arguments)); + WithCloseParenTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(CloseParenToken)); + } + private TupleExpressionSyntaxWrapper(ExpressionSyntax node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleTypeSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleTypeSyntaxWrapper.g.cs index 73df8ad7d7..6aa162c716 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleTypeSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleTypeSyntaxWrapper.g.cs @@ -20,6 +20,17 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func WithOpenParenTokenAccessor; private static readonly Func, TypeSyntax> WithElementsAccessor; private static readonly Func WithCloseParenTokenAccessor; + static TupleTypeSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(TupleTypeSyntaxWrapper)); + OpenParenTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(OpenParenToken)); + ElementsAccessor = LightupHelpers.CreateSeparatedSyntaxListPropertyAccessor(WrappedType, nameof(Elements)); + CloseParenTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(CloseParenToken)); + WithOpenParenTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(OpenParenToken)); + WithElementsAccessor = LightupHelpers.CreateSeparatedSyntaxListWithPropertyAccessor(WrappedType, nameof(Elements)); + WithCloseParenTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(CloseParenToken)); + } + private TupleTypeSyntaxWrapper(TypeSyntax node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TypePatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TypePatternSyntaxWrapper.g.cs index 14041c21f5..3ddda2760f 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TypePatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TypePatternSyntaxWrapper.g.cs @@ -16,6 +16,13 @@ namespace StyleCop.Analyzers.Lightup private readonly CSharpSyntaxNode node; private static readonly Func TypeAccessor; private static readonly Func WithTypeAccessor; + static TypePatternSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(TypePatternSyntaxWrapper)); + TypeAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Type)); + WithTypeAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Type)); + } + private TypePatternSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/UnaryPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/UnaryPatternSyntaxWrapper.g.cs index eb06de7b2a..fe58bfcdf3 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/UnaryPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/UnaryPatternSyntaxWrapper.g.cs @@ -18,6 +18,15 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func PatternAccessor; private static readonly Func WithOperatorTokenAccessor; private static readonly Func WithPatternAccessor; + static UnaryPatternSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(UnaryPatternSyntaxWrapper)); + OperatorTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(OperatorToken)); + PatternAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Pattern)); + WithOperatorTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(OperatorToken)); + WithPatternAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Pattern)); + } + private UnaryPatternSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VarPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VarPatternSyntaxWrapper.g.cs index b1dbbb68af..ea284f0201 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VarPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VarPatternSyntaxWrapper.g.cs @@ -18,6 +18,15 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func DesignationAccessor; private static readonly Func WithVarKeywordAccessor; private static readonly Func WithDesignationAccessor; + static VarPatternSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(VarPatternSyntaxWrapper)); + VarKeywordAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(VarKeyword)); + DesignationAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Designation)); + WithVarKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(VarKeyword)); + WithDesignationAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Designation)); + } + private VarPatternSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VariableDesignationSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VariableDesignationSyntaxWrapper.g.cs index f03a004491..986f2ccf7c 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VariableDesignationSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VariableDesignationSyntaxWrapper.g.cs @@ -14,6 +14,11 @@ namespace StyleCop.Analyzers.Lightup internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax"; private static readonly Type WrappedType; private readonly CSharpSyntaxNode node; + static VariableDesignationSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(VariableDesignationSyntaxWrapper)); + } + private VariableDesignationSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WhenClauseSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WhenClauseSyntaxWrapper.g.cs index 1896d4d7a0..4cf16712d1 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WhenClauseSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WhenClauseSyntaxWrapper.g.cs @@ -18,6 +18,15 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func ConditionAccessor; private static readonly Func WithWhenKeywordAccessor; private static readonly Func WithConditionAccessor; + static WhenClauseSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(WhenClauseSyntaxWrapper)); + WhenKeywordAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(WhenKeyword)); + ConditionAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Condition)); + WithWhenKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(WhenKeyword)); + WithConditionAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Condition)); + } + private WhenClauseSyntaxWrapper(CSharpSyntaxNode node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WithExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WithExpressionSyntaxWrapper.g.cs index 16b71f78ea..6134e548ec 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WithExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WithExpressionSyntaxWrapper.g.cs @@ -20,6 +20,17 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func WithExpressionAccessor; private static readonly Func WithWithKeywordAccessor; private static readonly Func WithInitializerAccessor; + static WithExpressionSyntaxWrapper() + { + WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(WithExpressionSyntaxWrapper)); + ExpressionAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Expression)); + WithKeywordAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(WithKeyword)); + InitializerAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Initializer)); + WithExpressionAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Expression)); + WithWithKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(WithKeyword)); + WithInitializerAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Initializer)); + } + private WithExpressionSyntaxWrapper(ExpressionSyntax node) { this.node = node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CasePatternSwitchLabelSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CasePatternSwitchLabelSyntaxWrapper.cs index b7a82603e7..45dcbe4e2b 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CasePatternSwitchLabelSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CasePatternSwitchLabelSyntaxWrapper.cs @@ -4,22 +4,10 @@ namespace StyleCop.Analyzers.Lightup { using Microsoft.CodeAnalysis; - using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.CSharp.Syntax; internal partial struct CasePatternSwitchLabelSyntaxWrapper : ISyntaxWrapper { - static CasePatternSwitchLabelSyntaxWrapper() - { - WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(CasePatternSwitchLabelSyntaxWrapper)); - PatternAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Pattern)); - WhenClauseAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(WhenClause)); - WithKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(SwitchLabelSyntax.Keyword)); - WithColonTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(SwitchLabelSyntax.ColonToken)); - WithPatternAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Pattern)); - WithWhenClauseAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(WhenClause)); - } - public PatternSyntaxWrapper Pattern { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CommonForEachStatementSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CommonForEachStatementSyntaxWrapper.cs index 26ba3ef671..337be7575b 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CommonForEachStatementSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CommonForEachStatementSyntaxWrapper.cs @@ -10,26 +10,6 @@ internal partial struct CommonForEachStatementSyntaxWrapper : ISyntaxWrapper(WrappedType, nameof(AwaitKeyword)); - ForEachKeywordAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(ForEachKeyword)); - OpenParenTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(OpenParenToken)); - InKeywordAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(InKeyword)); - ExpressionAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Expression)); - CloseParenTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(CloseParenToken)); - StatementAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Statement)); - - WithAwaitKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(AwaitKeyword)); - WithForEachKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(ForEachKeyword)); - WithOpenParenTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(OpenParenToken)); - WithInKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(InKeyword)); - WithExpressionAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Expression)); - WithCloseParenTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(CloseParenToken)); - WithStatementAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Statement)); - } - public SyntaxToken AwaitKeyword { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ConstantPatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ConstantPatternSyntaxWrapper.cs index 148382c908..d334814830 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ConstantPatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ConstantPatternSyntaxWrapper.cs @@ -8,13 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct ConstantPatternSyntaxWrapper : ISyntaxWrapper { - static ConstantPatternSyntaxWrapper() - { - WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(ConstantPatternSyntaxWrapper)); - ExpressionAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Expression)); - WithExpressionAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Expression)); - } - public ExpressionSyntax Expression { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationExpressionSyntaxWrapper.cs index 0b7a281a16..6418f43d3b 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationExpressionSyntaxWrapper.cs @@ -3,20 +3,10 @@ namespace StyleCop.Analyzers.Lightup { - using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.CSharp.Syntax; internal partial struct DeclarationExpressionSyntaxWrapper : ISyntaxWrapper { - static DeclarationExpressionSyntaxWrapper() - { - WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(DeclarationExpressionSyntaxWrapper)); - TypeAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Type)); - DesignationAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Designation)); - WithTypeAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Type)); - WithDesignationAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Designation)); - } - public TypeSyntax Type { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationPatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationPatternSyntaxWrapper.cs index 49cbfbd8fb..32456297dc 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationPatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationPatternSyntaxWrapper.cs @@ -8,15 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct DeclarationPatternSyntaxWrapper : ISyntaxWrapper { - static DeclarationPatternSyntaxWrapper() - { - WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(DeclarationPatternSyntaxWrapper)); - TypeAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Type)); - DesignationAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Designation)); - WithTypeAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Type)); - WithDesignationAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Designation)); - } - public TypeSyntax Type { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardDesignationSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardDesignationSyntaxWrapper.cs index d6000f65e4..490601bc75 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardDesignationSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardDesignationSyntaxWrapper.cs @@ -8,13 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct DiscardDesignationSyntaxWrapper : ISyntaxWrapper { - static DiscardDesignationSyntaxWrapper() - { - WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(DiscardDesignationSyntaxWrapper)); - UnderscoreTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(UnderscoreToken)); - WithUnderscoreTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(UnderscoreToken)); - } - public SyntaxToken UnderscoreToken { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardPatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardPatternSyntaxWrapper.cs index d74ab04aff..32885dcee4 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardPatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardPatternSyntaxWrapper.cs @@ -8,13 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct DiscardPatternSyntaxWrapper : ISyntaxWrapper { - static DiscardPatternSyntaxWrapper() - { - WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(DiscardPatternSyntaxWrapper)); - UnderscoreTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(UnderscoreToken)); - WithUnderscoreTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(UnderscoreToken)); - } - public SyntaxToken UnderscoreToken { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ForEachVariableStatementSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ForEachVariableStatementSyntaxWrapper.cs index 07edfdd5e0..0ddd4a532c 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ForEachVariableStatementSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ForEachVariableStatementSyntaxWrapper.cs @@ -8,21 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct ForEachVariableStatementSyntaxWrapper : ISyntaxWrapper { - static ForEachVariableStatementSyntaxWrapper() - { - WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(ForEachVariableStatementSyntaxWrapper)); - VariableAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Variable)); - - WithAwaitKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(AwaitKeyword)); - WithForEachKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(ForEachKeyword)); - WithOpenParenTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(OpenParenToken)); - WithVariableAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Variable)); - WithInKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(InKeyword)); - WithExpressionAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Expression)); - WithCloseParenTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(CloseParenToken)); - WithStatementAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Statement)); - } - public SyntaxToken AwaitKeyword { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.cs index dc88c6ecb1..1ce960915d 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.cs @@ -8,19 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct ImplicitStackAllocArrayCreationExpressionSyntaxWrapper : ISyntaxWrapper { - static ImplicitStackAllocArrayCreationExpressionSyntaxWrapper() - { - WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(ImplicitStackAllocArrayCreationExpressionSyntaxWrapper)); - StackAllocKeywordAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(StackAllocKeyword)); - OpenBracketTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(OpenBracketToken)); - CloseBracketTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(CloseBracketToken)); - InitializerAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Initializer)); - WithStackAllocKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(StackAllocKeyword)); - WithOpenBracketTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(OpenBracketToken)); - WithCloseBracketTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(CloseBracketToken)); - WithInitializerAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Initializer)); - } - public SyntaxToken StackAllocKeyword { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/IsPatternExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/IsPatternExpressionSyntaxWrapper.cs index e31bb1a85c..bd63a8effd 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/IsPatternExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/IsPatternExpressionSyntaxWrapper.cs @@ -4,22 +4,10 @@ namespace StyleCop.Analyzers.Lightup { using Microsoft.CodeAnalysis; - using Microsoft.CodeAnalysis.CSharp; using Microsoft.CodeAnalysis.CSharp.Syntax; internal partial struct IsPatternExpressionSyntaxWrapper : ISyntaxWrapper { - static IsPatternExpressionSyntaxWrapper() - { - WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(IsPatternExpressionSyntaxWrapper)); - ExpressionAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Expression)); - IsKeywordAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(IsKeyword)); - PatternAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Pattern)); - WithExpressionAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Expression)); - WithIsKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(IsKeyword)); - WithPatternAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Pattern)); - } - public ExpressionSyntax Expression { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/LocalFunctionStatementSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/LocalFunctionStatementSyntaxWrapper.cs index 380bb53df7..1b4a4ac6f6 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/LocalFunctionStatementSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/LocalFunctionStatementSyntaxWrapper.cs @@ -9,29 +9,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct LocalFunctionStatementSyntaxWrapper : ISyntaxWrapper { - static LocalFunctionStatementSyntaxWrapper() - { - WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(LocalFunctionStatementSyntaxWrapper)); - ModifiersAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Modifiers)); - ReturnTypeAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(ReturnType)); - IdentifierAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Identifier)); - TypeParameterListAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(TypeParameterList)); - ParameterListAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(ParameterList)); - ConstraintClausesAccessor = LightupHelpers.CreateSyntaxPropertyAccessor>(WrappedType, nameof(ConstraintClauses)); - BodyAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Body)); - ExpressionBodyAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(ExpressionBody)); - SemicolonTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(SemicolonToken)); - WithModifiersAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Modifiers)); - WithReturnTypeAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(ReturnType)); - WithIdentifierAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Identifier)); - WithTypeParameterListAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(TypeParameterList)); - WithParameterListAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(ParameterList)); - WithConstraintClausesAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor>(WrappedType, nameof(ConstraintClauses)); - WithBodyAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Body)); - WithExpressionBodyAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(ExpressionBody)); - WithSemicolonTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(SemicolonToken)); - } - public SyntaxTokenList Modifiers { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ParenthesizedVariableDesignationSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ParenthesizedVariableDesignationSyntaxWrapper.cs index 2470b392db..d3b330e406 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ParenthesizedVariableDesignationSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ParenthesizedVariableDesignationSyntaxWrapper.cs @@ -8,17 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct ParenthesizedVariableDesignationSyntaxWrapper : ISyntaxWrapper { - static ParenthesizedVariableDesignationSyntaxWrapper() - { - WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(ParenthesizedVariableDesignationSyntaxWrapper)); - OpenParenTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(OpenParenToken)); - VariablesAccessor = LightupHelpers.CreateSeparatedSyntaxListPropertyAccessor(WrappedType, nameof(Variables)); - CloseParenTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(CloseParenToken)); - WithOpenParenTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(OpenParenToken)); - WithVariablesAccessor = LightupHelpers.CreateSeparatedSyntaxListWithPropertyAccessor(WrappedType, nameof(Variables)); - WithCloseParenTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(CloseParenToken)); - } - public SyntaxToken OpenParenToken { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PatternSyntaxWrapper.cs deleted file mode 100644 index d14851e6b4..0000000000 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PatternSyntaxWrapper.cs +++ /dev/null @@ -1,15 +0,0 @@ -// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. -// Licensed under the MIT License. See LICENSE in the project root for license information. - -namespace StyleCop.Analyzers.Lightup -{ - using Microsoft.CodeAnalysis.CSharp; - - internal partial struct PatternSyntaxWrapper : ISyntaxWrapper - { - static PatternSyntaxWrapper() - { - WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(PatternSyntaxWrapper)); - } - } -} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PositionalPatternClauseSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PositionalPatternClauseSyntaxWrapper.cs index 9e6c6328f3..8e11c68164 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PositionalPatternClauseSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PositionalPatternClauseSyntaxWrapper.cs @@ -8,18 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct PositionalPatternClauseSyntaxWrapper : ISyntaxWrapper { - static PositionalPatternClauseSyntaxWrapper() - { - WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(PositionalPatternClauseSyntaxWrapper)); - OpenParenTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(OpenParenToken)); - SubpatternsAccessor = LightupHelpers.CreateSeparatedSyntaxListPropertyAccessor(WrappedType, nameof(Subpatterns)); - CloseParenTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(CloseParenToken)); - - WithOpenParenTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(OpenParenToken)); - WithSubpatternsAccessor = LightupHelpers.CreateSeparatedSyntaxListWithPropertyAccessor(WrappedType, nameof(Subpatterns)); - WithCloseParenTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(CloseParenToken)); - } - public SyntaxToken OpenParenToken { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PropertyPatternClauseSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PropertyPatternClauseSyntaxWrapper.cs index 097e6ba857..4b0d73803f 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PropertyPatternClauseSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PropertyPatternClauseSyntaxWrapper.cs @@ -8,18 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct PropertyPatternClauseSyntaxWrapper : ISyntaxWrapper { - static PropertyPatternClauseSyntaxWrapper() - { - WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(PropertyPatternClauseSyntaxWrapper)); - OpenBraceTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(OpenBraceToken)); - SubpatternsAccessor = LightupHelpers.CreateSeparatedSyntaxListPropertyAccessor(WrappedType, nameof(Subpatterns)); - CloseBraceTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(CloseBraceToken)); - - WithOpenBraceTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(OpenBraceToken)); - WithSubpatternsAccessor = LightupHelpers.CreateSeparatedSyntaxListWithPropertyAccessor(WrappedType, nameof(Subpatterns)); - WithCloseBraceTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(CloseBraceToken)); - } - public SyntaxToken OpenBraceToken { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RangeExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RangeExpressionSyntaxWrapper.cs index cc1887cab6..b8234c071d 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RangeExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RangeExpressionSyntaxWrapper.cs @@ -8,18 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct RangeExpressionSyntaxWrapper : ISyntaxWrapper { - static RangeExpressionSyntaxWrapper() - { - WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(RangeExpressionSyntaxWrapper)); - LeftOperandAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(LeftOperand)); - OperatorTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(OperatorToken)); - RightOperandAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(RightOperand)); - - WithLeftOperandAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(LeftOperand)); - WithOperatorTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(OperatorToken)); - WithRightOperandAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(RightOperand)); - } - public ExpressionSyntax LeftOperand { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RecursivePatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RecursivePatternSyntaxWrapper.cs index 789c4fcbf8..8d4423627c 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RecursivePatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RecursivePatternSyntaxWrapper.cs @@ -8,20 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct RecursivePatternSyntaxWrapper : ISyntaxWrapper { - static RecursivePatternSyntaxWrapper() - { - WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(RecursivePatternSyntaxWrapper)); - TypeAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Type)); - PositionalPatternClauseAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(PositionalPatternClause)); - PropertyPatternClauseAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(PropertyPatternClause)); - DesignationAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Designation)); - - WithTypeAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Type)); - WithPositionalPatternClauseAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(PositionalPatternClause)); - WithPropertyPatternClauseAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(PropertyPatternClause)); - WithDesignationAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Designation)); - } - public TypeSyntax Type { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefExpressionSyntaxWrapper.cs index b53f09c65b..3e36170b1b 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefExpressionSyntaxWrapper.cs @@ -8,15 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct RefExpressionSyntaxWrapper : ISyntaxWrapper { - static RefExpressionSyntaxWrapper() - { - WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(RefExpressionSyntaxWrapper)); - RefKeywordAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(RefKeyword)); - ExpressionAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Expression)); - WithRefKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(RefKeyword)); - WithExpressionAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Expression)); - } - public SyntaxToken RefKeyword { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefTypeSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefTypeSyntaxWrapper.cs index fbce0a3144..8736829403 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefTypeSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefTypeSyntaxWrapper.cs @@ -8,17 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct RefTypeSyntaxWrapper : ISyntaxWrapper { - static RefTypeSyntaxWrapper() - { - WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(RefTypeSyntaxWrapper)); - RefKeywordAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(RefKeyword)); - ReadOnlyKeywordAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(ReadOnlyKeyword)); - TypeAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Type)); - WithRefKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(RefKeyword)); - WithReadOnlyKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(ReadOnlyKeyword)); - WithTypeAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Type)); - } - public SyntaxToken RefKeyword { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SingleVariableDesignationSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SingleVariableDesignationSyntaxWrapper.cs index d9dea90c2a..c4bfe8d099 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SingleVariableDesignationSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SingleVariableDesignationSyntaxWrapper.cs @@ -8,13 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct SingleVariableDesignationSyntaxWrapper : ISyntaxWrapper { - static SingleVariableDesignationSyntaxWrapper() - { - WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(SingleVariableDesignationSyntaxWrapper)); - IdentifierAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Identifier)); - WithIdentifierAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Identifier)); - } - public SyntaxToken Identifier { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SubpatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SubpatternSyntaxWrapper.cs index 17ca4e87fb..e3734fe6f8 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SubpatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SubpatternSyntaxWrapper.cs @@ -8,16 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct SubpatternSyntaxWrapper : ISyntaxWrapper { - static SubpatternSyntaxWrapper() - { - WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(SubpatternSyntaxWrapper)); - NameColonAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(NameColon)); - PatternAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Pattern)); - - WithNameColonAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(NameColon)); - WithPatternAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Pattern)); - } - public NameColonSyntax NameColon { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionArmSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionArmSyntaxWrapper.cs index 6896b7b6c5..623f1518c1 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionArmSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionArmSyntaxWrapper.cs @@ -9,20 +9,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct SwitchExpressionArmSyntaxWrapper : ISyntaxWrapper { - static SwitchExpressionArmSyntaxWrapper() - { - WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(SwitchExpressionArmSyntaxWrapper)); - PatternAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Pattern)); - WhenClauseAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(WhenClause)); - ExpressionAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Expression)); - EqualsGreaterThanTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(EqualsGreaterThanToken)); - - WithPatternAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Pattern)); - WithWhenClauseAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(WhenClause)); - WithExpressionAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Expression)); - WithEqualsGreaterThanTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(EqualsGreaterThanToken)); - } - public PatternSyntaxWrapper Pattern { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionSyntaxWrapper.cs index 556cb5fa5b..b300282a3c 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionSyntaxWrapper.cs @@ -8,22 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct SwitchExpressionSyntaxWrapper : ISyntaxWrapper { - static SwitchExpressionSyntaxWrapper() - { - WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(SwitchExpressionSyntaxWrapper)); - ArmsAccessor = LightupHelpers.CreateSeparatedSyntaxListPropertyAccessor(WrappedType, nameof(Arms)); - GoverningExpressionAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(GoverningExpression)); - OpenBraceTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(OpenBraceToken)); - SwitchKeywordAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(SwitchKeyword)); - CloseBraceTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(CloseBraceToken)); - - WithArmsAccessor = LightupHelpers.CreateSeparatedSyntaxListWithPropertyAccessor(WrappedType, nameof(Arms)); - WithGoverningExpressionAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(GoverningExpression)); - WithOpenBraceTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(OpenBraceToken)); - WithSwitchKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(SwitchKeyword)); - WithCloseBraceTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(CloseBraceToken)); - } - public ExpressionSyntax GoverningExpression { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ThrowExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ThrowExpressionSyntaxWrapper.cs index 8b150ad26e..25cebb2692 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ThrowExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ThrowExpressionSyntaxWrapper.cs @@ -8,15 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct ThrowExpressionSyntaxWrapper : ISyntaxWrapper { - static ThrowExpressionSyntaxWrapper() - { - WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(ThrowExpressionSyntaxWrapper)); - ThrowKeywordAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(ThrowKeyword)); - ExpressionAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Expression)); - WithThrowKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(ThrowKeyword)); - WithExpressionAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Expression)); - } - public SyntaxToken ThrowKeyword { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleElementSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleElementSyntaxWrapper.cs index 0513df695b..04f2cfaa18 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleElementSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleElementSyntaxWrapper.cs @@ -9,15 +9,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct TupleElementSyntaxWrapper : ISyntaxWrapper { - static TupleElementSyntaxWrapper() - { - WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(TupleElementSyntaxWrapper)); - IdentifierAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Identifier)); - TypeAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Type)); - WithIdentifierAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Identifier)); - WithTypeAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Type)); - } - public SyntaxToken Identifier { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleExpressionSyntaxWrapper.cs index 97ffb59142..5001d3cc24 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleExpressionSyntaxWrapper.cs @@ -8,17 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct TupleExpressionSyntaxWrapper : ISyntaxWrapper { - static TupleExpressionSyntaxWrapper() - { - WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(TupleExpressionSyntaxWrapper)); - OpenParenTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(OpenParenToken)); - ArgumentsAccessor = LightupHelpers.CreateSyntaxPropertyAccessor>(WrappedType, nameof(Arguments)); - CloseParenTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(CloseParenToken)); - WithOpenParenTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(OpenParenToken)); - WithArgumentsAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor>(WrappedType, nameof(Arguments)); - WithCloseParenTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(CloseParenToken)); - } - public SyntaxToken OpenParenToken { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleTypeSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleTypeSyntaxWrapper.cs index ea93eba17f..eff1571018 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleTypeSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleTypeSyntaxWrapper.cs @@ -8,17 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct TupleTypeSyntaxWrapper : ISyntaxWrapper { - static TupleTypeSyntaxWrapper() - { - WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(TupleTypeSyntaxWrapper)); - OpenParenTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(OpenParenToken)); - ElementsAccessor = LightupHelpers.CreateSeparatedSyntaxListPropertyAccessor(WrappedType, nameof(Elements)); - CloseParenTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(CloseParenToken)); - WithOpenParenTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(OpenParenToken)); - WithElementsAccessor = LightupHelpers.CreateSeparatedSyntaxListWithPropertyAccessor(WrappedType, nameof(Elements)); - WithCloseParenTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(CloseParenToken)); - } - public SyntaxToken OpenParenToken { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VarPatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VarPatternSyntaxWrapper.cs index 1e51d987ff..69694e804c 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VarPatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VarPatternSyntaxWrapper.cs @@ -8,16 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct VarPatternSyntaxWrapper : ISyntaxWrapper { - static VarPatternSyntaxWrapper() - { - WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(VarPatternSyntaxWrapper)); - VarKeywordAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(VarKeyword)); - DesignationAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Designation)); - - WithVarKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(VarKeyword)); - WithDesignationAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Designation)); - } - public SyntaxToken VarKeyword { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VariableDesignationSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VariableDesignationSyntaxWrapper.cs deleted file mode 100644 index b841a5af00..0000000000 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VariableDesignationSyntaxWrapper.cs +++ /dev/null @@ -1,15 +0,0 @@ -// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. -// Licensed under the MIT License. See LICENSE in the project root for license information. - -namespace StyleCop.Analyzers.Lightup -{ - using Microsoft.CodeAnalysis.CSharp; - - internal partial struct VariableDesignationSyntaxWrapper : ISyntaxWrapper - { - static VariableDesignationSyntaxWrapper() - { - WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(VariableDesignationSyntaxWrapper)); - } - } -} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/WhenClauseSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/WhenClauseSyntaxWrapper.cs index 918fbef4d1..4e11040295 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/WhenClauseSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/WhenClauseSyntaxWrapper.cs @@ -9,15 +9,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct WhenClauseSyntaxWrapper : ISyntaxWrapper { - static WhenClauseSyntaxWrapper() - { - WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(WhenClauseSyntaxWrapper)); - WhenKeywordAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(WhenKeyword)); - ConditionAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Condition)); - WithWhenKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(WhenKeyword)); - WithConditionAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Condition)); - } - public SyntaxToken WhenKeyword { get From efeef8daebebba92ff06f5a8cdf1287289f0b06d Mon Sep 17 00:00:00 2001 From: Sam Harwell Date: Tue, 17 Nov 2020 07:18:48 -0800 Subject: [PATCH 11/18] Generate static fields before instance fields --- .../SyntaxLightupGenerator.cs | 16 ++++++++-------- ...aseObjectCreationExpressionSyntaxWrapper.g.cs | 2 +- .../BaseParameterSyntaxWrapper.g.cs | 2 +- .../BinaryPatternSyntaxWrapper.g.cs | 2 +- .../CasePatternSwitchLabelSyntaxWrapper.g.cs | 2 +- .../CommonForEachStatementSyntaxWrapper.g.cs | 2 +- .../ConstantPatternSyntaxWrapper.g.cs | 2 +- .../DeclarationExpressionSyntaxWrapper.g.cs | 2 +- .../DeclarationPatternSyntaxWrapper.g.cs | 2 +- .../DefaultConstraintSyntaxWrapper.g.cs | 2 +- .../DiscardDesignationSyntaxWrapper.g.cs | 2 +- .../DiscardPatternSyntaxWrapper.g.cs | 2 +- .../ForEachVariableStatementSyntaxWrapper.g.cs | 2 +- ...ionPointerCallingConventionSyntaxWrapper.g.cs | 2 +- ...unctionPointerParameterListSyntaxWrapper.g.cs | 2 +- .../FunctionPointerParameterSyntaxWrapper.g.cs | 2 +- .../FunctionPointerTypeSyntaxWrapper.g.cs | 2 +- ...anagedCallingConventionListSyntaxWrapper.g.cs | 2 +- ...rUnmanagedCallingConventionSyntaxWrapper.g.cs | 2 +- ...citObjectCreationExpressionSyntaxWrapper.g.cs | 2 +- ...llocArrayCreationExpressionSyntaxWrapper.g.cs | 2 +- .../IsPatternExpressionSyntaxWrapper.g.cs | 2 +- .../LocalFunctionStatementSyntaxWrapper.g.cs | 2 +- .../NullableDirectiveTriviaSyntaxWrapper.g.cs | 2 +- .../ParenthesizedPatternSyntaxWrapper.g.cs | 2 +- ...thesizedVariableDesignationSyntaxWrapper.g.cs | 2 +- .../PositionalPatternClauseSyntaxWrapper.g.cs | 2 +- .../PrimaryConstructorBaseTypeSyntaxWrapper.g.cs | 2 +- .../PropertyPatternClauseSyntaxWrapper.g.cs | 2 +- .../RangeExpressionSyntaxWrapper.g.cs | 2 +- .../RecordDeclarationSyntaxWrapper.g.cs | 2 +- .../RecursivePatternSyntaxWrapper.g.cs | 2 +- .../RefExpressionSyntaxWrapper.g.cs | 2 +- .../RefTypeSyntaxWrapper.g.cs | 2 +- .../RelationalPatternSyntaxWrapper.g.cs | 2 +- .../SingleVariableDesignationSyntaxWrapper.g.cs | 2 +- .../SubpatternSyntaxWrapper.g.cs | 2 +- .../SwitchExpressionArmSyntaxWrapper.g.cs | 2 +- .../SwitchExpressionSyntaxWrapper.g.cs | 2 +- .../ThrowExpressionSyntaxWrapper.g.cs | 2 +- .../TupleElementSyntaxWrapper.g.cs | 2 +- .../TupleExpressionSyntaxWrapper.g.cs | 2 +- .../TupleTypeSyntaxWrapper.g.cs | 2 +- .../TypePatternSyntaxWrapper.g.cs | 2 +- .../UnaryPatternSyntaxWrapper.g.cs | 2 +- .../VarPatternSyntaxWrapper.g.cs | 2 +- .../WhenClauseSyntaxWrapper.g.cs | 2 +- .../WithExpressionSyntaxWrapper.g.cs | 2 +- 48 files changed, 55 insertions(+), 55 deletions(-) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs b/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs index 6cc7b7003a..da09bbb68f 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs @@ -85,14 +85,6 @@ private void GenerateSyntaxWrapper(in GeneratorExecutionContext context, SyntaxD type: SyntaxFactory.IdentifierName("Type"), variables: SyntaxFactory.SingletonSeparatedList(SyntaxFactory.VariableDeclarator("WrappedType"))))); - // private readonly SyntaxNode node; - members = members.Add(SyntaxFactory.FieldDeclaration( - attributeLists: default, - modifiers: SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PrivateKeyword), SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword)), - declaration: SyntaxFactory.VariableDeclaration( - type: SyntaxFactory.IdentifierName(concreteBase), - variables: SyntaxFactory.SingletonSeparatedList(SyntaxFactory.VariableDeclarator("node"))))); - foreach (var field in nodeData.Fields) { if (field.IsSkipped) @@ -146,6 +138,14 @@ private void GenerateSyntaxWrapper(in GeneratorExecutionContext context, SyntaxD variables: SyntaxFactory.SingletonSeparatedList(SyntaxFactory.VariableDeclarator(field.WithAccessorName))))); } + // private readonly SyntaxNode node; + members = members.Add(SyntaxFactory.FieldDeclaration( + attributeLists: default, + modifiers: SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PrivateKeyword), SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword)), + declaration: SyntaxFactory.VariableDeclaration( + type: SyntaxFactory.IdentifierName(concreteBase), + variables: SyntaxFactory.SingletonSeparatedList(SyntaxFactory.VariableDeclarator("node"))))); + // WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(SyntaxWrapper)); var staticCtorStatements = SyntaxFactory.SingletonList( SyntaxFactory.ExpressionStatement(SyntaxFactory.AssignmentExpression( diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseObjectCreationExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseObjectCreationExpressionSyntaxWrapper.g.cs index 88371bb06d..eeeb4848d7 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseObjectCreationExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseObjectCreationExpressionSyntaxWrapper.g.cs @@ -13,13 +13,13 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax"; private static readonly Type WrappedType; - private readonly ExpressionSyntax node; private static readonly Func NewKeywordAccessor; private static readonly Func ArgumentListAccessor; private static readonly Func InitializerAccessor; private static readonly Func WithNewKeywordAccessor; private static readonly Func WithArgumentListAccessor; private static readonly Func WithInitializerAccessor; + private readonly ExpressionSyntax node; static BaseObjectCreationExpressionSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(BaseObjectCreationExpressionSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseParameterSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseParameterSyntaxWrapper.g.cs index 579be994fa..bc146a42b4 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseParameterSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseParameterSyntaxWrapper.g.cs @@ -13,13 +13,13 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax"; private static readonly Type WrappedType; - private readonly CSharpSyntaxNode node; private static readonly Func> AttributeListsAccessor; private static readonly Func ModifiersAccessor; private static readonly Func TypeAccessor; private static readonly Func, CSharpSyntaxNode> WithAttributeListsAccessor; private static readonly Func WithModifiersAccessor; private static readonly Func WithTypeAccessor; + private readonly CSharpSyntaxNode node; static BaseParameterSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(BaseParameterSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BinaryPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BinaryPatternSyntaxWrapper.g.cs index b8fff84df7..ddd7bd52f2 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BinaryPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BinaryPatternSyntaxWrapper.g.cs @@ -13,13 +13,13 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax"; private static readonly Type WrappedType; - private readonly CSharpSyntaxNode node; private static readonly Func LeftAccessor; private static readonly Func OperatorTokenAccessor; private static readonly Func RightAccessor; private static readonly Func WithLeftAccessor; private static readonly Func WithOperatorTokenAccessor; private static readonly Func WithRightAccessor; + private readonly CSharpSyntaxNode node; static BinaryPatternSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(BinaryPatternSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CasePatternSwitchLabelSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CasePatternSwitchLabelSyntaxWrapper.g.cs index 0c7c3a13c3..9444224496 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CasePatternSwitchLabelSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CasePatternSwitchLabelSyntaxWrapper.g.cs @@ -13,13 +13,13 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax"; private static readonly Type WrappedType; - private readonly SwitchLabelSyntax node; private static readonly Func PatternAccessor; private static readonly Func WhenClauseAccessor; private static readonly Func WithKeywordAccessor; private static readonly Func WithPatternAccessor; private static readonly Func WithWhenClauseAccessor; private static readonly Func WithColonTokenAccessor; + private readonly SwitchLabelSyntax node; static CasePatternSwitchLabelSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(CasePatternSwitchLabelSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CommonForEachStatementSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CommonForEachStatementSyntaxWrapper.g.cs index 3c97ead6a9..d952f828d5 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CommonForEachStatementSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CommonForEachStatementSyntaxWrapper.g.cs @@ -13,7 +13,6 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax"; private static readonly Type WrappedType; - private readonly StatementSyntax node; private static readonly Func AwaitKeywordAccessor; private static readonly Func ForEachKeywordAccessor; private static readonly Func OpenParenTokenAccessor; @@ -28,6 +27,7 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func WithExpressionAccessor; private static readonly Func WithCloseParenTokenAccessor; private static readonly Func WithStatementAccessor; + private readonly StatementSyntax node; static CommonForEachStatementSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(CommonForEachStatementSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ConstantPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ConstantPatternSyntaxWrapper.g.cs index d861279a30..3c07449069 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ConstantPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ConstantPatternSyntaxWrapper.g.cs @@ -13,9 +13,9 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax"; private static readonly Type WrappedType; - private readonly CSharpSyntaxNode node; private static readonly Func ExpressionAccessor; private static readonly Func WithExpressionAccessor; + private readonly CSharpSyntaxNode node; static ConstantPatternSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(ConstantPatternSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationExpressionSyntaxWrapper.g.cs index a7135cc2cf..a1e8f1dea8 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationExpressionSyntaxWrapper.g.cs @@ -13,11 +13,11 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax"; private static readonly Type WrappedType; - private readonly ExpressionSyntax node; private static readonly Func TypeAccessor; private static readonly Func DesignationAccessor; private static readonly Func WithTypeAccessor; private static readonly Func WithDesignationAccessor; + private readonly ExpressionSyntax node; static DeclarationExpressionSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(DeclarationExpressionSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationPatternSyntaxWrapper.g.cs index be1475f1e6..bcd66a10a9 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationPatternSyntaxWrapper.g.cs @@ -13,11 +13,11 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax"; private static readonly Type WrappedType; - private readonly CSharpSyntaxNode node; private static readonly Func TypeAccessor; private static readonly Func DesignationAccessor; private static readonly Func WithTypeAccessor; private static readonly Func WithDesignationAccessor; + private readonly CSharpSyntaxNode node; static DeclarationPatternSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(DeclarationPatternSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DefaultConstraintSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DefaultConstraintSyntaxWrapper.g.cs index 9d3a16b1de..ffc8da18ea 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DefaultConstraintSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DefaultConstraintSyntaxWrapper.g.cs @@ -13,9 +13,9 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax"; private static readonly Type WrappedType; - private readonly TypeParameterConstraintSyntax node; private static readonly Func DefaultKeywordAccessor; private static readonly Func WithDefaultKeywordAccessor; + private readonly TypeParameterConstraintSyntax node; static DefaultConstraintSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(DefaultConstraintSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardDesignationSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardDesignationSyntaxWrapper.g.cs index 49d7837bb6..b9588340f9 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardDesignationSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardDesignationSyntaxWrapper.g.cs @@ -13,9 +13,9 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax"; private static readonly Type WrappedType; - private readonly CSharpSyntaxNode node; private static readonly Func UnderscoreTokenAccessor; private static readonly Func WithUnderscoreTokenAccessor; + private readonly CSharpSyntaxNode node; static DiscardDesignationSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(DiscardDesignationSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardPatternSyntaxWrapper.g.cs index 61ba0ffa17..1e04ef85be 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardPatternSyntaxWrapper.g.cs @@ -13,9 +13,9 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax"; private static readonly Type WrappedType; - private readonly CSharpSyntaxNode node; private static readonly Func UnderscoreTokenAccessor; private static readonly Func WithUnderscoreTokenAccessor; + private readonly CSharpSyntaxNode node; static DiscardPatternSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(DiscardPatternSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ForEachVariableStatementSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ForEachVariableStatementSyntaxWrapper.g.cs index dabc1843e6..8f5f35a861 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ForEachVariableStatementSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ForEachVariableStatementSyntaxWrapper.g.cs @@ -13,7 +13,6 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax"; private static readonly Type WrappedType; - private readonly StatementSyntax node; private static readonly Func VariableAccessor; private static readonly Func, StatementSyntax> WithAttributeListsAccessor; private static readonly Func WithAwaitKeywordAccessor; @@ -24,6 +23,7 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func WithExpressionAccessor; private static readonly Func WithCloseParenTokenAccessor; private static readonly Func WithStatementAccessor; + private readonly StatementSyntax node; static ForEachVariableStatementSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(ForEachVariableStatementSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerCallingConventionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerCallingConventionSyntaxWrapper.g.cs index 3612717919..8cf2d828bd 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerCallingConventionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerCallingConventionSyntaxWrapper.g.cs @@ -13,11 +13,11 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax"; private static readonly Type WrappedType; - private readonly CSharpSyntaxNode node; private static readonly Func ManagedOrUnmanagedKeywordAccessor; private static readonly Func UnmanagedCallingConventionListAccessor; private static readonly Func WithManagedOrUnmanagedKeywordAccessor; private static readonly Func WithUnmanagedCallingConventionListAccessor; + private readonly CSharpSyntaxNode node; static FunctionPointerCallingConventionSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(FunctionPointerCallingConventionSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterListSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterListSyntaxWrapper.g.cs index e7e869fd83..ff82f80af6 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterListSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterListSyntaxWrapper.g.cs @@ -13,13 +13,13 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax"; private static readonly Type WrappedType; - private readonly CSharpSyntaxNode node; private static readonly Func LessThanTokenAccessor; private static readonly Func> ParametersAccessor; private static readonly Func GreaterThanTokenAccessor; private static readonly Func WithLessThanTokenAccessor; private static readonly Func, CSharpSyntaxNode> WithParametersAccessor; private static readonly Func WithGreaterThanTokenAccessor; + private readonly CSharpSyntaxNode node; static FunctionPointerParameterListSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(FunctionPointerParameterListSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterSyntaxWrapper.g.cs index fb33495334..0b82bb7365 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterSyntaxWrapper.g.cs @@ -13,10 +13,10 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax"; private static readonly Type WrappedType; - private readonly CSharpSyntaxNode node; private static readonly Func, CSharpSyntaxNode> WithAttributeListsAccessor; private static readonly Func WithModifiersAccessor; private static readonly Func WithTypeAccessor; + private readonly CSharpSyntaxNode node; static FunctionPointerParameterSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(FunctionPointerParameterSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerTypeSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerTypeSyntaxWrapper.g.cs index df5d733c8b..42dcbb1622 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerTypeSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerTypeSyntaxWrapper.g.cs @@ -13,7 +13,6 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax"; private static readonly Type WrappedType; - private readonly TypeSyntax node; private static readonly Func DelegateKeywordAccessor; private static readonly Func AsteriskTokenAccessor; private static readonly Func CallingConventionAccessor; @@ -22,6 +21,7 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func WithAsteriskTokenAccessor; private static readonly Func WithCallingConventionAccessor; private static readonly Func WithParameterListAccessor; + private readonly TypeSyntax node; static FunctionPointerTypeSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(FunctionPointerTypeSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionListSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionListSyntaxWrapper.g.cs index 2b4c2d7e8e..cfc1b62633 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionListSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionListSyntaxWrapper.g.cs @@ -13,13 +13,13 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax"; private static readonly Type WrappedType; - private readonly CSharpSyntaxNode node; private static readonly Func OpenBracketTokenAccessor; private static readonly Func> CallingConventionsAccessor; private static readonly Func CloseBracketTokenAccessor; private static readonly Func WithOpenBracketTokenAccessor; private static readonly Func, CSharpSyntaxNode> WithCallingConventionsAccessor; private static readonly Func WithCloseBracketTokenAccessor; + private readonly CSharpSyntaxNode node; static FunctionPointerUnmanagedCallingConventionListSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(FunctionPointerUnmanagedCallingConventionListSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionSyntaxWrapper.g.cs index 857c2792a7..e1006ed183 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionSyntaxWrapper.g.cs @@ -13,9 +13,9 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax"; private static readonly Type WrappedType; - private readonly CSharpSyntaxNode node; private static readonly Func NameAccessor; private static readonly Func WithNameAccessor; + private readonly CSharpSyntaxNode node; static FunctionPointerUnmanagedCallingConventionSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(FunctionPointerUnmanagedCallingConventionSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitObjectCreationExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitObjectCreationExpressionSyntaxWrapper.g.cs index 88184d42a6..f987fcf590 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitObjectCreationExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitObjectCreationExpressionSyntaxWrapper.g.cs @@ -13,10 +13,10 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax"; private static readonly Type WrappedType; - private readonly ExpressionSyntax node; private static readonly Func WithNewKeywordAccessor; private static readonly Func WithArgumentListAccessor; private static readonly Func WithInitializerAccessor; + private readonly ExpressionSyntax node; static ImplicitObjectCreationExpressionSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(ImplicitObjectCreationExpressionSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.g.cs index a1c4e48a3d..2a71bc5c17 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.g.cs @@ -13,7 +13,6 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax"; private static readonly Type WrappedType; - private readonly ExpressionSyntax node; private static readonly Func StackAllocKeywordAccessor; private static readonly Func OpenBracketTokenAccessor; private static readonly Func CloseBracketTokenAccessor; @@ -22,6 +21,7 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func WithOpenBracketTokenAccessor; private static readonly Func WithCloseBracketTokenAccessor; private static readonly Func WithInitializerAccessor; + private readonly ExpressionSyntax node; static ImplicitStackAllocArrayCreationExpressionSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(ImplicitStackAllocArrayCreationExpressionSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/IsPatternExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/IsPatternExpressionSyntaxWrapper.g.cs index d0b2269435..6a9f297e86 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/IsPatternExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/IsPatternExpressionSyntaxWrapper.g.cs @@ -13,13 +13,13 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax"; private static readonly Type WrappedType; - private readonly ExpressionSyntax node; private static readonly Func ExpressionAccessor; private static readonly Func IsKeywordAccessor; private static readonly Func PatternAccessor; private static readonly Func WithExpressionAccessor; private static readonly Func WithIsKeywordAccessor; private static readonly Func WithPatternAccessor; + private readonly ExpressionSyntax node; static IsPatternExpressionSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(IsPatternExpressionSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/LocalFunctionStatementSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/LocalFunctionStatementSyntaxWrapper.g.cs index 35594d8eee..061cab4f21 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/LocalFunctionStatementSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/LocalFunctionStatementSyntaxWrapper.g.cs @@ -13,7 +13,6 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax"; private static readonly Type WrappedType; - private readonly StatementSyntax node; private static readonly Func ModifiersAccessor; private static readonly Func ReturnTypeAccessor; private static readonly Func IdentifierAccessor; @@ -33,6 +32,7 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func WithBodyAccessor; private static readonly Func WithExpressionBodyAccessor; private static readonly Func WithSemicolonTokenAccessor; + private readonly StatementSyntax node; static LocalFunctionStatementSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(LocalFunctionStatementSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/NullableDirectiveTriviaSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/NullableDirectiveTriviaSyntaxWrapper.g.cs index addd566f02..7122c3d6f1 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/NullableDirectiveTriviaSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/NullableDirectiveTriviaSyntaxWrapper.g.cs @@ -13,7 +13,6 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax"; private static readonly Type WrappedType; - private readonly DirectiveTriviaSyntax node; private static readonly Func NullableKeywordAccessor; private static readonly Func SettingTokenAccessor; private static readonly Func TargetTokenAccessor; @@ -23,6 +22,7 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func WithTargetTokenAccessor; private static readonly Func WithEndOfDirectiveTokenAccessor; private static readonly Func WithIsActiveAccessor; + private readonly DirectiveTriviaSyntax node; static NullableDirectiveTriviaSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(NullableDirectiveTriviaSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedPatternSyntaxWrapper.g.cs index 0e19a0fe46..86521dc4a1 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedPatternSyntaxWrapper.g.cs @@ -13,13 +13,13 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax"; private static readonly Type WrappedType; - private readonly CSharpSyntaxNode node; private static readonly Func OpenParenTokenAccessor; private static readonly Func PatternAccessor; private static readonly Func CloseParenTokenAccessor; private static readonly Func WithOpenParenTokenAccessor; private static readonly Func WithPatternAccessor; private static readonly Func WithCloseParenTokenAccessor; + private readonly CSharpSyntaxNode node; static ParenthesizedPatternSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(ParenthesizedPatternSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedVariableDesignationSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedVariableDesignationSyntaxWrapper.g.cs index 00878dd435..a5c0eee129 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedVariableDesignationSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedVariableDesignationSyntaxWrapper.g.cs @@ -13,13 +13,13 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax"; private static readonly Type WrappedType; - private readonly CSharpSyntaxNode node; private static readonly Func OpenParenTokenAccessor; private static readonly Func> VariablesAccessor; private static readonly Func CloseParenTokenAccessor; private static readonly Func WithOpenParenTokenAccessor; private static readonly Func, CSharpSyntaxNode> WithVariablesAccessor; private static readonly Func WithCloseParenTokenAccessor; + private readonly CSharpSyntaxNode node; static ParenthesizedVariableDesignationSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(ParenthesizedVariableDesignationSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PositionalPatternClauseSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PositionalPatternClauseSyntaxWrapper.g.cs index 44f4b2f3f8..30a6686f96 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PositionalPatternClauseSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PositionalPatternClauseSyntaxWrapper.g.cs @@ -13,13 +13,13 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax"; private static readonly Type WrappedType; - private readonly CSharpSyntaxNode node; private static readonly Func OpenParenTokenAccessor; private static readonly Func> SubpatternsAccessor; private static readonly Func CloseParenTokenAccessor; private static readonly Func WithOpenParenTokenAccessor; private static readonly Func, CSharpSyntaxNode> WithSubpatternsAccessor; private static readonly Func WithCloseParenTokenAccessor; + private readonly CSharpSyntaxNode node; static PositionalPatternClauseSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(PositionalPatternClauseSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PrimaryConstructorBaseTypeSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PrimaryConstructorBaseTypeSyntaxWrapper.g.cs index 8a3312e9aa..843face6c2 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PrimaryConstructorBaseTypeSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PrimaryConstructorBaseTypeSyntaxWrapper.g.cs @@ -13,10 +13,10 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax"; private static readonly Type WrappedType; - private readonly BaseTypeSyntax node; private static readonly Func ArgumentListAccessor; private static readonly Func WithTypeAccessor; private static readonly Func WithArgumentListAccessor; + private readonly BaseTypeSyntax node; static PrimaryConstructorBaseTypeSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(PrimaryConstructorBaseTypeSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PropertyPatternClauseSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PropertyPatternClauseSyntaxWrapper.g.cs index 1ea74d0dfa..61bb2ce1cf 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PropertyPatternClauseSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PropertyPatternClauseSyntaxWrapper.g.cs @@ -13,13 +13,13 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax"; private static readonly Type WrappedType; - private readonly CSharpSyntaxNode node; private static readonly Func OpenBraceTokenAccessor; private static readonly Func> SubpatternsAccessor; private static readonly Func CloseBraceTokenAccessor; private static readonly Func WithOpenBraceTokenAccessor; private static readonly Func, CSharpSyntaxNode> WithSubpatternsAccessor; private static readonly Func WithCloseBraceTokenAccessor; + private readonly CSharpSyntaxNode node; static PropertyPatternClauseSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(PropertyPatternClauseSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RangeExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RangeExpressionSyntaxWrapper.g.cs index 9dfb9fc5b4..6614915a1b 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RangeExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RangeExpressionSyntaxWrapper.g.cs @@ -13,13 +13,13 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax"; private static readonly Type WrappedType; - private readonly ExpressionSyntax node; private static readonly Func LeftOperandAccessor; private static readonly Func OperatorTokenAccessor; private static readonly Func RightOperandAccessor; private static readonly Func WithLeftOperandAccessor; private static readonly Func WithOperatorTokenAccessor; private static readonly Func WithRightOperandAccessor; + private readonly ExpressionSyntax node; static RangeExpressionSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(RangeExpressionSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecordDeclarationSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecordDeclarationSyntaxWrapper.g.cs index 88ea5b850f..ece5993dba 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecordDeclarationSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecordDeclarationSyntaxWrapper.g.cs @@ -13,7 +13,6 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax"; private static readonly Type WrappedType; - private readonly TypeDeclarationSyntax node; private static readonly Func ParameterListAccessor; private static readonly Func, TypeDeclarationSyntax> WithAttributeListsAccessor; private static readonly Func WithModifiersAccessor; @@ -27,6 +26,7 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func, TypeDeclarationSyntax> WithMembersAccessor; private static readonly Func WithCloseBraceTokenAccessor; private static readonly Func WithSemicolonTokenAccessor; + private readonly TypeDeclarationSyntax node; static RecordDeclarationSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(RecordDeclarationSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecursivePatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecursivePatternSyntaxWrapper.g.cs index 6e9fd8c130..edcde76e48 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecursivePatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecursivePatternSyntaxWrapper.g.cs @@ -13,7 +13,6 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax"; private static readonly Type WrappedType; - private readonly CSharpSyntaxNode node; private static readonly Func TypeAccessor; private static readonly Func PositionalPatternClauseAccessor; private static readonly Func PropertyPatternClauseAccessor; @@ -22,6 +21,7 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func WithPositionalPatternClauseAccessor; private static readonly Func WithPropertyPatternClauseAccessor; private static readonly Func WithDesignationAccessor; + private readonly CSharpSyntaxNode node; static RecursivePatternSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(RecursivePatternSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefExpressionSyntaxWrapper.g.cs index 78b2acd0d6..7325167cca 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefExpressionSyntaxWrapper.g.cs @@ -13,11 +13,11 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax"; private static readonly Type WrappedType; - private readonly ExpressionSyntax node; private static readonly Func RefKeywordAccessor; private static readonly Func ExpressionAccessor; private static readonly Func WithRefKeywordAccessor; private static readonly Func WithExpressionAccessor; + private readonly ExpressionSyntax node; static RefExpressionSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(RefExpressionSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefTypeSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefTypeSyntaxWrapper.g.cs index ebb331b9ad..0960c162a3 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefTypeSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefTypeSyntaxWrapper.g.cs @@ -13,13 +13,13 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax"; private static readonly Type WrappedType; - private readonly TypeSyntax node; private static readonly Func RefKeywordAccessor; private static readonly Func ReadOnlyKeywordAccessor; private static readonly Func TypeAccessor; private static readonly Func WithRefKeywordAccessor; private static readonly Func WithReadOnlyKeywordAccessor; private static readonly Func WithTypeAccessor; + private readonly TypeSyntax node; static RefTypeSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(RefTypeSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RelationalPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RelationalPatternSyntaxWrapper.g.cs index 9cf5c08980..750152b2a6 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RelationalPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RelationalPatternSyntaxWrapper.g.cs @@ -13,11 +13,11 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax"; private static readonly Type WrappedType; - private readonly CSharpSyntaxNode node; private static readonly Func OperatorTokenAccessor; private static readonly Func ExpressionAccessor; private static readonly Func WithOperatorTokenAccessor; private static readonly Func WithExpressionAccessor; + private readonly CSharpSyntaxNode node; static RelationalPatternSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(RelationalPatternSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SingleVariableDesignationSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SingleVariableDesignationSyntaxWrapper.g.cs index b52911956a..9db6a16879 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SingleVariableDesignationSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SingleVariableDesignationSyntaxWrapper.g.cs @@ -13,9 +13,9 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax"; private static readonly Type WrappedType; - private readonly CSharpSyntaxNode node; private static readonly Func IdentifierAccessor; private static readonly Func WithIdentifierAccessor; + private readonly CSharpSyntaxNode node; static SingleVariableDesignationSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(SingleVariableDesignationSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SubpatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SubpatternSyntaxWrapper.g.cs index 2b28f59bba..e61747cb2f 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SubpatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SubpatternSyntaxWrapper.g.cs @@ -13,11 +13,11 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax"; private static readonly Type WrappedType; - private readonly CSharpSyntaxNode node; private static readonly Func NameColonAccessor; private static readonly Func PatternAccessor; private static readonly Func WithNameColonAccessor; private static readonly Func WithPatternAccessor; + private readonly CSharpSyntaxNode node; static SubpatternSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(SubpatternSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionArmSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionArmSyntaxWrapper.g.cs index 3cf390649e..cfe71e3779 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionArmSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionArmSyntaxWrapper.g.cs @@ -13,7 +13,6 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax"; private static readonly Type WrappedType; - private readonly CSharpSyntaxNode node; private static readonly Func PatternAccessor; private static readonly Func WhenClauseAccessor; private static readonly Func EqualsGreaterThanTokenAccessor; @@ -22,6 +21,7 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func WithWhenClauseAccessor; private static readonly Func WithEqualsGreaterThanTokenAccessor; private static readonly Func WithExpressionAccessor; + private readonly CSharpSyntaxNode node; static SwitchExpressionArmSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(SwitchExpressionArmSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionSyntaxWrapper.g.cs index 13d34a09f6..6168d1d5ab 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionSyntaxWrapper.g.cs @@ -13,7 +13,6 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax"; private static readonly Type WrappedType; - private readonly ExpressionSyntax node; private static readonly Func GoverningExpressionAccessor; private static readonly Func SwitchKeywordAccessor; private static readonly Func OpenBraceTokenAccessor; @@ -24,6 +23,7 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func WithOpenBraceTokenAccessor; private static readonly Func, ExpressionSyntax> WithArmsAccessor; private static readonly Func WithCloseBraceTokenAccessor; + private readonly ExpressionSyntax node; static SwitchExpressionSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(SwitchExpressionSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ThrowExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ThrowExpressionSyntaxWrapper.g.cs index 51197e5c19..3613a9d11f 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ThrowExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ThrowExpressionSyntaxWrapper.g.cs @@ -13,11 +13,11 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax"; private static readonly Type WrappedType; - private readonly ExpressionSyntax node; private static readonly Func ThrowKeywordAccessor; private static readonly Func ExpressionAccessor; private static readonly Func WithThrowKeywordAccessor; private static readonly Func WithExpressionAccessor; + private readonly ExpressionSyntax node; static ThrowExpressionSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(ThrowExpressionSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleElementSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleElementSyntaxWrapper.g.cs index 65fc6e11ff..a0c514df75 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleElementSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleElementSyntaxWrapper.g.cs @@ -13,11 +13,11 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax"; private static readonly Type WrappedType; - private readonly CSharpSyntaxNode node; private static readonly Func TypeAccessor; private static readonly Func IdentifierAccessor; private static readonly Func WithTypeAccessor; private static readonly Func WithIdentifierAccessor; + private readonly CSharpSyntaxNode node; static TupleElementSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(TupleElementSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleExpressionSyntaxWrapper.g.cs index 026b0c5953..4d5c5323be 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleExpressionSyntaxWrapper.g.cs @@ -13,13 +13,13 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax"; private static readonly Type WrappedType; - private readonly ExpressionSyntax node; private static readonly Func OpenParenTokenAccessor; private static readonly Func> ArgumentsAccessor; private static readonly Func CloseParenTokenAccessor; private static readonly Func WithOpenParenTokenAccessor; private static readonly Func, ExpressionSyntax> WithArgumentsAccessor; private static readonly Func WithCloseParenTokenAccessor; + private readonly ExpressionSyntax node; static TupleExpressionSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(TupleExpressionSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleTypeSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleTypeSyntaxWrapper.g.cs index 6aa162c716..36c607430a 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleTypeSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleTypeSyntaxWrapper.g.cs @@ -13,13 +13,13 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax"; private static readonly Type WrappedType; - private readonly TypeSyntax node; private static readonly Func OpenParenTokenAccessor; private static readonly Func> ElementsAccessor; private static readonly Func CloseParenTokenAccessor; private static readonly Func WithOpenParenTokenAccessor; private static readonly Func, TypeSyntax> WithElementsAccessor; private static readonly Func WithCloseParenTokenAccessor; + private readonly TypeSyntax node; static TupleTypeSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(TupleTypeSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TypePatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TypePatternSyntaxWrapper.g.cs index 3ddda2760f..6b6162cd9d 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TypePatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TypePatternSyntaxWrapper.g.cs @@ -13,9 +13,9 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax"; private static readonly Type WrappedType; - private readonly CSharpSyntaxNode node; private static readonly Func TypeAccessor; private static readonly Func WithTypeAccessor; + private readonly CSharpSyntaxNode node; static TypePatternSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(TypePatternSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/UnaryPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/UnaryPatternSyntaxWrapper.g.cs index fe58bfcdf3..684582a272 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/UnaryPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/UnaryPatternSyntaxWrapper.g.cs @@ -13,11 +13,11 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax"; private static readonly Type WrappedType; - private readonly CSharpSyntaxNode node; private static readonly Func OperatorTokenAccessor; private static readonly Func PatternAccessor; private static readonly Func WithOperatorTokenAccessor; private static readonly Func WithPatternAccessor; + private readonly CSharpSyntaxNode node; static UnaryPatternSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(UnaryPatternSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VarPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VarPatternSyntaxWrapper.g.cs index ea284f0201..38c7d605e0 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VarPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VarPatternSyntaxWrapper.g.cs @@ -13,11 +13,11 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax"; private static readonly Type WrappedType; - private readonly CSharpSyntaxNode node; private static readonly Func VarKeywordAccessor; private static readonly Func DesignationAccessor; private static readonly Func WithVarKeywordAccessor; private static readonly Func WithDesignationAccessor; + private readonly CSharpSyntaxNode node; static VarPatternSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(VarPatternSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WhenClauseSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WhenClauseSyntaxWrapper.g.cs index 4cf16712d1..8c60bfd62e 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WhenClauseSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WhenClauseSyntaxWrapper.g.cs @@ -13,11 +13,11 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax"; private static readonly Type WrappedType; - private readonly CSharpSyntaxNode node; private static readonly Func WhenKeywordAccessor; private static readonly Func ConditionAccessor; private static readonly Func WithWhenKeywordAccessor; private static readonly Func WithConditionAccessor; + private readonly CSharpSyntaxNode node; static WhenClauseSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(WhenClauseSyntaxWrapper)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WithExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WithExpressionSyntaxWrapper.g.cs index 6134e548ec..130217886b 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WithExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WithExpressionSyntaxWrapper.g.cs @@ -13,13 +13,13 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax"; private static readonly Type WrappedType; - private readonly ExpressionSyntax node; private static readonly Func ExpressionAccessor; private static readonly Func WithKeywordAccessor; private static readonly Func InitializerAccessor; private static readonly Func WithExpressionAccessor; private static readonly Func WithWithKeywordAccessor; private static readonly Func WithInitializerAccessor; + private readonly ExpressionSyntax node; static WithExpressionSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(WithExpressionSyntaxWrapper)); From 5b17a6d34ada3d90faf873ee2da8a6693c659811 Mon Sep 17 00:00:00 2001 From: Sam Harwell Date: Tue, 17 Nov 2020 07:28:56 -0800 Subject: [PATCH 12/18] Generate wrapper properties --- .../SyntaxLightupGenerator.cs | 107 ++++++++++++++++++ ...ObjectCreationExpressionSyntaxWrapper.g.cs | 24 ++++ .../BaseParameterSyntaxWrapper.g.cs | 24 ++++ .../BinaryPatternSyntaxWrapper.g.cs | 24 ++++ .../CasePatternSwitchLabelSyntaxWrapper.g.cs | 32 ++++++ .../CommonForEachStatementSyntaxWrapper.g.cs | 56 +++++++++ .../ConstantPatternSyntaxWrapper.g.cs | 8 ++ .../DeclarationExpressionSyntaxWrapper.g.cs | 16 +++ .../DeclarationPatternSyntaxWrapper.g.cs | 16 +++ .../DefaultConstraintSyntaxWrapper.g.cs | 8 ++ .../DiscardDesignationSyntaxWrapper.g.cs | 8 ++ .../DiscardPatternSyntaxWrapper.g.cs | 8 ++ ...ForEachVariableStatementSyntaxWrapper.g.cs | 64 +++++++++++ ...PointerCallingConventionSyntaxWrapper.g.cs | 16 +++ ...tionPointerParameterListSyntaxWrapper.g.cs | 24 ++++ ...FunctionPointerParameterSyntaxWrapper.g.cs | 24 ++++ .../FunctionPointerTypeSyntaxWrapper.g.cs | 32 ++++++ ...gedCallingConventionListSyntaxWrapper.g.cs | 24 ++++ ...managedCallingConventionSyntaxWrapper.g.cs | 8 ++ ...ObjectCreationExpressionSyntaxWrapper.g.cs | 24 ++++ ...cArrayCreationExpressionSyntaxWrapper.g.cs | 32 ++++++ .../IsPatternExpressionSyntaxWrapper.g.cs | 24 ++++ .../LocalFunctionStatementSyntaxWrapper.g.cs | 72 ++++++++++++ .../NullableDirectiveTriviaSyntaxWrapper.g.cs | 48 ++++++++ .../ParenthesizedPatternSyntaxWrapper.g.cs | 24 ++++ ...sizedVariableDesignationSyntaxWrapper.g.cs | 24 ++++ .../PositionalPatternClauseSyntaxWrapper.g.cs | 24 ++++ ...imaryConstructorBaseTypeSyntaxWrapper.g.cs | 16 +++ .../PropertyPatternClauseSyntaxWrapper.g.cs | 24 ++++ .../RangeExpressionSyntaxWrapper.g.cs | 24 ++++ .../RecordDeclarationSyntaxWrapper.g.cs | 96 ++++++++++++++++ .../RecursivePatternSyntaxWrapper.g.cs | 32 ++++++ .../RefExpressionSyntaxWrapper.g.cs | 16 +++ .../RefTypeSyntaxWrapper.g.cs | 24 ++++ .../RelationalPatternSyntaxWrapper.g.cs | 16 +++ ...ingleVariableDesignationSyntaxWrapper.g.cs | 8 ++ .../SubpatternSyntaxWrapper.g.cs | 16 +++ .../SwitchExpressionArmSyntaxWrapper.g.cs | 32 ++++++ .../SwitchExpressionSyntaxWrapper.g.cs | 40 +++++++ .../ThrowExpressionSyntaxWrapper.g.cs | 16 +++ .../TupleElementSyntaxWrapper.g.cs | 16 +++ .../TupleExpressionSyntaxWrapper.g.cs | 24 ++++ .../TupleTypeSyntaxWrapper.g.cs | 24 ++++ .../TypePatternSyntaxWrapper.g.cs | 8 ++ .../UnaryPatternSyntaxWrapper.g.cs | 16 +++ .../VarPatternSyntaxWrapper.g.cs | 16 +++ .../WhenClauseSyntaxWrapper.g.cs | 16 +++ .../WithExpressionSyntaxWrapper.g.cs | 24 ++++ .../CasePatternSwitchLabelSyntaxWrapper.cs | 16 --- .../CommonForEachStatementSyntaxWrapper.cs | 56 --------- .../Lightup/ConstantPatternSyntaxWrapper.cs | 8 -- .../DeclarationExpressionSyntaxWrapper.cs | 16 --- .../DeclarationPatternSyntaxWrapper.cs | 16 --- .../DiscardDesignationSyntaxWrapper.cs | 8 -- .../Lightup/DiscardPatternSyntaxWrapper.cs | 8 -- .../ForEachVariableStatementSyntaxWrapper.cs | 64 ----------- ...locArrayCreationExpressionSyntaxWrapper.cs | 32 ------ .../IsPatternExpressionSyntaxWrapper.cs | 24 ---- .../LocalFunctionStatementSyntaxWrapper.cs | 72 ------------ ...hesizedVariableDesignationSyntaxWrapper.cs | 24 ---- .../PositionalPatternClauseSyntaxWrapper.cs | 24 ---- .../PropertyPatternClauseSyntaxWrapper.cs | 24 ---- .../Lightup/RangeExpressionSyntaxWrapper.cs | 24 ---- .../Lightup/RecursivePatternSyntaxWrapper.cs | 32 ------ .../Lightup/RefExpressionSyntaxWrapper.cs | 16 --- .../Lightup/RefTypeSyntaxWrapper.cs | 24 ---- .../SingleVariableDesignationSyntaxWrapper.cs | 8 -- .../Lightup/SubpatternSyntaxWrapper.cs | 16 --- .../SwitchExpressionArmSyntaxWrapper.cs | 32 ------ .../Lightup/SwitchExpressionSyntaxWrapper.cs | 40 ------- .../Lightup/ThrowExpressionSyntaxWrapper.cs | 16 --- .../Lightup/TupleElementSyntaxWrapper.cs | 16 --- .../Lightup/TupleExpressionSyntaxWrapper.cs | 24 ---- .../Lightup/TupleTypeSyntaxWrapper.cs | 24 ---- .../Lightup/VarPatternSyntaxWrapper.cs | 16 --- .../Lightup/WhenClauseSyntaxWrapper.cs | 16 --- 76 files changed, 1299 insertions(+), 696 deletions(-) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs b/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs index da09bbb68f..b11bce707c 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs @@ -326,6 +326,113 @@ private void GenerateSyntaxWrapper(in GeneratorExecutionContext context, SyntaxD initializer: null, semicolonToken: SyntaxFactory.Token(SyntaxKind.SemicolonToken))); + // public T Field + // { + // get + // { + // return ...; + // } + // } + foreach (var field in nodeData.Fields) + { + if (field.IsSkipped) + { + continue; + } + + TypeSyntax propertyType = SyntaxFactory.ParseTypeName(field.GetAccessorResultType(syntaxData)); + ExpressionSyntax returnExpression; + if (field.IsOverride) + { + var declaringNode = field.GetDeclaringNode(syntaxData); + if (declaringNode.WrapperName is not null) + { + // ((CommonForEachStatementSyntaxWrapper)this).OpenParenToken + returnExpression = SyntaxFactory.MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + expression: SyntaxFactory.ParenthesizedExpression( + SyntaxFactory.CastExpression( + type: SyntaxFactory.IdentifierName(declaringNode.WrapperName ?? declaringNode.Name), + expression: SyntaxFactory.ThisExpression())), + name: SyntaxFactory.IdentifierName(field.Name)); + } + else + { + // this.SyntaxNode.OpenParenToken + returnExpression = SyntaxFactory.MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + expression: SyntaxFactory.MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + expression: SyntaxFactory.ThisExpression(), + name: SyntaxFactory.IdentifierName("SyntaxNode")), + name: SyntaxFactory.IdentifierName(field.Name)); + } + } + else if (field.IsWrappedSeparatedSyntaxList(syntaxData, out var elementNode)) + { + // PatternAccessor(this.SyntaxNode) + returnExpression = SyntaxFactory.InvocationExpression( + expression: SyntaxFactory.IdentifierName(field.AccessorName), + argumentList: SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Argument( + SyntaxFactory.MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + expression: SyntaxFactory.ThisExpression(), + name: SyntaxFactory.IdentifierName("SyntaxNode")))))); + } + else if (syntaxData.TryGetNode(field.Type) is { } fieldNodeType) + { + // PatternAccessor(this.SyntaxNode) + returnExpression = SyntaxFactory.InvocationExpression( + expression: SyntaxFactory.IdentifierName(field.AccessorName), + argumentList: SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Argument( + SyntaxFactory.MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + expression: SyntaxFactory.ThisExpression(), + name: SyntaxFactory.IdentifierName("SyntaxNode")))))); + + if (fieldNodeType.WrapperName is not null) + { + // (PatternSyntaxWrapper)... + propertyType = SyntaxFactory.IdentifierName(fieldNodeType.WrapperName); + returnExpression = SyntaxFactory.CastExpression( + type: SyntaxFactory.IdentifierName(fieldNodeType.WrapperName), + expression: returnExpression); + } + } + else + { + // PatternAccessor(this.SyntaxNode) + returnExpression = SyntaxFactory.InvocationExpression( + expression: SyntaxFactory.IdentifierName(field.AccessorName), + argumentList: SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Argument( + SyntaxFactory.MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + expression: SyntaxFactory.ThisExpression(), + name: SyntaxFactory.IdentifierName("SyntaxNode")))))); + } + + // public T Field + // { + // get + // { + // return ...; + // } + // } + members = members.Add(SyntaxFactory.PropertyDeclaration( + attributeLists: default, + modifiers: SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword)), + type: propertyType, + explicitInterfaceSpecifier: null, + identifier: SyntaxFactory.Identifier(field.Name), + accessorList: SyntaxFactory.AccessorList(SyntaxFactory.SingletonList(SyntaxFactory.AccessorDeclaration( + SyntaxKind.GetAccessorDeclaration, + SyntaxFactory.Block( + SyntaxFactory.ReturnStatement(returnExpression))))), + expressionBody: null, + initializer: null, + semicolonToken: default)); + } + // public static explicit operator WhenClauseSyntaxWrapper(SyntaxNode node) // { // if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseObjectCreationExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseObjectCreationExpressionSyntaxWrapper.g.cs index eeeb4848d7..240fc473de 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseObjectCreationExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseObjectCreationExpressionSyntaxWrapper.g.cs @@ -37,6 +37,30 @@ private BaseObjectCreationExpressionSyntaxWrapper(ExpressionSyntax node) } public ExpressionSyntax SyntaxNode => this.node; + public SyntaxToken NewKeyword + { + get + { + return NewKeywordAccessor(this.SyntaxNode); + } + } + + public ArgumentListSyntax ArgumentList + { + get + { + return ArgumentListAccessor(this.SyntaxNode); + } + } + + public InitializerExpressionSyntax Initializer + { + get + { + return InitializerAccessor(this.SyntaxNode); + } + } + public static explicit operator BaseObjectCreationExpressionSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseParameterSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseParameterSyntaxWrapper.g.cs index bc146a42b4..6aaa8832c1 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseParameterSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseParameterSyntaxWrapper.g.cs @@ -37,6 +37,30 @@ private BaseParameterSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public SyntaxList AttributeLists + { + get + { + return AttributeListsAccessor(this.SyntaxNode); + } + } + + public SyntaxTokenList Modifiers + { + get + { + return ModifiersAccessor(this.SyntaxNode); + } + } + + public TypeSyntax Type + { + get + { + return TypeAccessor(this.SyntaxNode); + } + } + public static explicit operator BaseParameterSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BinaryPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BinaryPatternSyntaxWrapper.g.cs index ddd7bd52f2..1a607301fc 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BinaryPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BinaryPatternSyntaxWrapper.g.cs @@ -37,6 +37,30 @@ private BinaryPatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public PatternSyntaxWrapper Left + { + get + { + return (PatternSyntaxWrapper)LeftAccessor(this.SyntaxNode); + } + } + + public SyntaxToken OperatorToken + { + get + { + return OperatorTokenAccessor(this.SyntaxNode); + } + } + + public PatternSyntaxWrapper Right + { + get + { + return (PatternSyntaxWrapper)RightAccessor(this.SyntaxNode); + } + } + public static explicit operator BinaryPatternSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CasePatternSwitchLabelSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CasePatternSwitchLabelSyntaxWrapper.g.cs index 9444224496..cd2616bda7 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CasePatternSwitchLabelSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CasePatternSwitchLabelSyntaxWrapper.g.cs @@ -37,6 +37,38 @@ private CasePatternSwitchLabelSyntaxWrapper(SwitchLabelSyntax node) } public SwitchLabelSyntax SyntaxNode => this.node; + public SyntaxToken Keyword + { + get + { + return this.SyntaxNode.Keyword; + } + } + + public PatternSyntaxWrapper Pattern + { + get + { + return (PatternSyntaxWrapper)PatternAccessor(this.SyntaxNode); + } + } + + public WhenClauseSyntaxWrapper WhenClause + { + get + { + return (WhenClauseSyntaxWrapper)WhenClauseAccessor(this.SyntaxNode); + } + } + + public SyntaxToken ColonToken + { + get + { + return this.SyntaxNode.ColonToken; + } + } + public static explicit operator CasePatternSwitchLabelSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CommonForEachStatementSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CommonForEachStatementSyntaxWrapper.g.cs index d952f828d5..5026e6ff5b 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CommonForEachStatementSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CommonForEachStatementSyntaxWrapper.g.cs @@ -53,6 +53,62 @@ private CommonForEachStatementSyntaxWrapper(StatementSyntax node) } public StatementSyntax SyntaxNode => this.node; + public SyntaxToken AwaitKeyword + { + get + { + return AwaitKeywordAccessor(this.SyntaxNode); + } + } + + public SyntaxToken ForEachKeyword + { + get + { + return ForEachKeywordAccessor(this.SyntaxNode); + } + } + + public SyntaxToken OpenParenToken + { + get + { + return OpenParenTokenAccessor(this.SyntaxNode); + } + } + + public SyntaxToken InKeyword + { + get + { + return InKeywordAccessor(this.SyntaxNode); + } + } + + public ExpressionSyntax Expression + { + get + { + return ExpressionAccessor(this.SyntaxNode); + } + } + + public SyntaxToken CloseParenToken + { + get + { + return CloseParenTokenAccessor(this.SyntaxNode); + } + } + + public StatementSyntax Statement + { + get + { + return StatementAccessor(this.SyntaxNode); + } + } + public static explicit operator CommonForEachStatementSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ConstantPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ConstantPatternSyntaxWrapper.g.cs index 3c07449069..435b4e196a 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ConstantPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ConstantPatternSyntaxWrapper.g.cs @@ -29,6 +29,14 @@ private ConstantPatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public ExpressionSyntax Expression + { + get + { + return ExpressionAccessor(this.SyntaxNode); + } + } + public static explicit operator ConstantPatternSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationExpressionSyntaxWrapper.g.cs index a1e8f1dea8..f2a3cb40cf 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationExpressionSyntaxWrapper.g.cs @@ -33,6 +33,22 @@ private DeclarationExpressionSyntaxWrapper(ExpressionSyntax node) } public ExpressionSyntax SyntaxNode => this.node; + public TypeSyntax Type + { + get + { + return TypeAccessor(this.SyntaxNode); + } + } + + public VariableDesignationSyntaxWrapper Designation + { + get + { + return (VariableDesignationSyntaxWrapper)DesignationAccessor(this.SyntaxNode); + } + } + public static explicit operator DeclarationExpressionSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationPatternSyntaxWrapper.g.cs index bcd66a10a9..029c26bbfb 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationPatternSyntaxWrapper.g.cs @@ -33,6 +33,22 @@ private DeclarationPatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public TypeSyntax Type + { + get + { + return TypeAccessor(this.SyntaxNode); + } + } + + public VariableDesignationSyntaxWrapper Designation + { + get + { + return (VariableDesignationSyntaxWrapper)DesignationAccessor(this.SyntaxNode); + } + } + public static explicit operator DeclarationPatternSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DefaultConstraintSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DefaultConstraintSyntaxWrapper.g.cs index ffc8da18ea..0e951fb067 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DefaultConstraintSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DefaultConstraintSyntaxWrapper.g.cs @@ -29,6 +29,14 @@ private DefaultConstraintSyntaxWrapper(TypeParameterConstraintSyntax node) } public TypeParameterConstraintSyntax SyntaxNode => this.node; + public SyntaxToken DefaultKeyword + { + get + { + return DefaultKeywordAccessor(this.SyntaxNode); + } + } + public static explicit operator DefaultConstraintSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardDesignationSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardDesignationSyntaxWrapper.g.cs index b9588340f9..244dd72cc7 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardDesignationSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardDesignationSyntaxWrapper.g.cs @@ -29,6 +29,14 @@ private DiscardDesignationSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public SyntaxToken UnderscoreToken + { + get + { + return UnderscoreTokenAccessor(this.SyntaxNode); + } + } + public static explicit operator DiscardDesignationSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardPatternSyntaxWrapper.g.cs index 1e04ef85be..719cfde137 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardPatternSyntaxWrapper.g.cs @@ -29,6 +29,14 @@ private DiscardPatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public SyntaxToken UnderscoreToken + { + get + { + return UnderscoreTokenAccessor(this.SyntaxNode); + } + } + public static explicit operator DiscardPatternSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ForEachVariableStatementSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ForEachVariableStatementSyntaxWrapper.g.cs index 8f5f35a861..7874523931 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ForEachVariableStatementSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ForEachVariableStatementSyntaxWrapper.g.cs @@ -45,6 +45,70 @@ private ForEachVariableStatementSyntaxWrapper(StatementSyntax node) } public StatementSyntax SyntaxNode => this.node; + public SyntaxToken AwaitKeyword + { + get + { + return ((CommonForEachStatementSyntaxWrapper)this).AwaitKeyword; + } + } + + public SyntaxToken ForEachKeyword + { + get + { + return ((CommonForEachStatementSyntaxWrapper)this).ForEachKeyword; + } + } + + public SyntaxToken OpenParenToken + { + get + { + return ((CommonForEachStatementSyntaxWrapper)this).OpenParenToken; + } + } + + public ExpressionSyntax Variable + { + get + { + return VariableAccessor(this.SyntaxNode); + } + } + + public SyntaxToken InKeyword + { + get + { + return ((CommonForEachStatementSyntaxWrapper)this).InKeyword; + } + } + + public ExpressionSyntax Expression + { + get + { + return ((CommonForEachStatementSyntaxWrapper)this).Expression; + } + } + + public SyntaxToken CloseParenToken + { + get + { + return ((CommonForEachStatementSyntaxWrapper)this).CloseParenToken; + } + } + + public StatementSyntax Statement + { + get + { + return ((CommonForEachStatementSyntaxWrapper)this).Statement; + } + } + public static explicit operator ForEachVariableStatementSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerCallingConventionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerCallingConventionSyntaxWrapper.g.cs index 8cf2d828bd..270ab8c88d 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerCallingConventionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerCallingConventionSyntaxWrapper.g.cs @@ -33,6 +33,22 @@ private FunctionPointerCallingConventionSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public SyntaxToken ManagedOrUnmanagedKeyword + { + get + { + return ManagedOrUnmanagedKeywordAccessor(this.SyntaxNode); + } + } + + public FunctionPointerUnmanagedCallingConventionListSyntaxWrapper UnmanagedCallingConventionList + { + get + { + return (FunctionPointerUnmanagedCallingConventionListSyntaxWrapper)UnmanagedCallingConventionListAccessor(this.SyntaxNode); + } + } + public static explicit operator FunctionPointerCallingConventionSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterListSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterListSyntaxWrapper.g.cs index ff82f80af6..7f59ceb57e 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterListSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterListSyntaxWrapper.g.cs @@ -37,6 +37,30 @@ private FunctionPointerParameterListSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public SyntaxToken LessThanToken + { + get + { + return LessThanTokenAccessor(this.SyntaxNode); + } + } + + public SeparatedSyntaxListWrapper Parameters + { + get + { + return ParametersAccessor(this.SyntaxNode); + } + } + + public SyntaxToken GreaterThanToken + { + get + { + return GreaterThanTokenAccessor(this.SyntaxNode); + } + } + public static explicit operator FunctionPointerParameterListSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterSyntaxWrapper.g.cs index 0b82bb7365..8aaba4caca 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterSyntaxWrapper.g.cs @@ -31,6 +31,30 @@ private FunctionPointerParameterSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public SyntaxList AttributeLists + { + get + { + return ((BaseParameterSyntaxWrapper)this).AttributeLists; + } + } + + public SyntaxTokenList Modifiers + { + get + { + return ((BaseParameterSyntaxWrapper)this).Modifiers; + } + } + + public TypeSyntax Type + { + get + { + return ((BaseParameterSyntaxWrapper)this).Type; + } + } + public static explicit operator FunctionPointerParameterSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerTypeSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerTypeSyntaxWrapper.g.cs index 42dcbb1622..23a1266759 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerTypeSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerTypeSyntaxWrapper.g.cs @@ -41,6 +41,38 @@ private FunctionPointerTypeSyntaxWrapper(TypeSyntax node) } public TypeSyntax SyntaxNode => this.node; + public SyntaxToken DelegateKeyword + { + get + { + return DelegateKeywordAccessor(this.SyntaxNode); + } + } + + public SyntaxToken AsteriskToken + { + get + { + return AsteriskTokenAccessor(this.SyntaxNode); + } + } + + public FunctionPointerCallingConventionSyntaxWrapper CallingConvention + { + get + { + return (FunctionPointerCallingConventionSyntaxWrapper)CallingConventionAccessor(this.SyntaxNode); + } + } + + public FunctionPointerParameterListSyntaxWrapper ParameterList + { + get + { + return (FunctionPointerParameterListSyntaxWrapper)ParameterListAccessor(this.SyntaxNode); + } + } + public static explicit operator FunctionPointerTypeSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionListSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionListSyntaxWrapper.g.cs index cfc1b62633..415075fb33 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionListSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionListSyntaxWrapper.g.cs @@ -37,6 +37,30 @@ private FunctionPointerUnmanagedCallingConventionListSyntaxWrapper(CSharpSyntaxN } public CSharpSyntaxNode SyntaxNode => this.node; + public SyntaxToken OpenBracketToken + { + get + { + return OpenBracketTokenAccessor(this.SyntaxNode); + } + } + + public SeparatedSyntaxListWrapper CallingConventions + { + get + { + return CallingConventionsAccessor(this.SyntaxNode); + } + } + + public SyntaxToken CloseBracketToken + { + get + { + return CloseBracketTokenAccessor(this.SyntaxNode); + } + } + public static explicit operator FunctionPointerUnmanagedCallingConventionListSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionSyntaxWrapper.g.cs index e1006ed183..712e3dfb35 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionSyntaxWrapper.g.cs @@ -29,6 +29,14 @@ private FunctionPointerUnmanagedCallingConventionSyntaxWrapper(CSharpSyntaxNode } public CSharpSyntaxNode SyntaxNode => this.node; + public SyntaxToken Name + { + get + { + return NameAccessor(this.SyntaxNode); + } + } + public static explicit operator FunctionPointerUnmanagedCallingConventionSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitObjectCreationExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitObjectCreationExpressionSyntaxWrapper.g.cs index f987fcf590..761ae91e0e 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitObjectCreationExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitObjectCreationExpressionSyntaxWrapper.g.cs @@ -31,6 +31,30 @@ private ImplicitObjectCreationExpressionSyntaxWrapper(ExpressionSyntax node) } public ExpressionSyntax SyntaxNode => this.node; + public SyntaxToken NewKeyword + { + get + { + return ((BaseObjectCreationExpressionSyntaxWrapper)this).NewKeyword; + } + } + + public ArgumentListSyntax ArgumentList + { + get + { + return ((BaseObjectCreationExpressionSyntaxWrapper)this).ArgumentList; + } + } + + public InitializerExpressionSyntax Initializer + { + get + { + return ((BaseObjectCreationExpressionSyntaxWrapper)this).Initializer; + } + } + public static explicit operator ImplicitObjectCreationExpressionSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.g.cs index 2a71bc5c17..9ce8b41bab 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.g.cs @@ -41,6 +41,38 @@ private ImplicitStackAllocArrayCreationExpressionSyntaxWrapper(ExpressionSyntax } public ExpressionSyntax SyntaxNode => this.node; + public SyntaxToken StackAllocKeyword + { + get + { + return StackAllocKeywordAccessor(this.SyntaxNode); + } + } + + public SyntaxToken OpenBracketToken + { + get + { + return OpenBracketTokenAccessor(this.SyntaxNode); + } + } + + public SyntaxToken CloseBracketToken + { + get + { + return CloseBracketTokenAccessor(this.SyntaxNode); + } + } + + public InitializerExpressionSyntax Initializer + { + get + { + return InitializerAccessor(this.SyntaxNode); + } + } + public static explicit operator ImplicitStackAllocArrayCreationExpressionSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/IsPatternExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/IsPatternExpressionSyntaxWrapper.g.cs index 6a9f297e86..fa4bf1b1fd 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/IsPatternExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/IsPatternExpressionSyntaxWrapper.g.cs @@ -37,6 +37,30 @@ private IsPatternExpressionSyntaxWrapper(ExpressionSyntax node) } public ExpressionSyntax SyntaxNode => this.node; + public ExpressionSyntax Expression + { + get + { + return ExpressionAccessor(this.SyntaxNode); + } + } + + public SyntaxToken IsKeyword + { + get + { + return IsKeywordAccessor(this.SyntaxNode); + } + } + + public PatternSyntaxWrapper Pattern + { + get + { + return (PatternSyntaxWrapper)PatternAccessor(this.SyntaxNode); + } + } + public static explicit operator IsPatternExpressionSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/LocalFunctionStatementSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/LocalFunctionStatementSyntaxWrapper.g.cs index 061cab4f21..0679b0468a 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/LocalFunctionStatementSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/LocalFunctionStatementSyntaxWrapper.g.cs @@ -63,6 +63,78 @@ private LocalFunctionStatementSyntaxWrapper(StatementSyntax node) } public StatementSyntax SyntaxNode => this.node; + public SyntaxTokenList Modifiers + { + get + { + return ModifiersAccessor(this.SyntaxNode); + } + } + + public TypeSyntax ReturnType + { + get + { + return ReturnTypeAccessor(this.SyntaxNode); + } + } + + public SyntaxToken Identifier + { + get + { + return IdentifierAccessor(this.SyntaxNode); + } + } + + public TypeParameterListSyntax TypeParameterList + { + get + { + return TypeParameterListAccessor(this.SyntaxNode); + } + } + + public ParameterListSyntax ParameterList + { + get + { + return ParameterListAccessor(this.SyntaxNode); + } + } + + public SyntaxList ConstraintClauses + { + get + { + return ConstraintClausesAccessor(this.SyntaxNode); + } + } + + public BlockSyntax Body + { + get + { + return BodyAccessor(this.SyntaxNode); + } + } + + public ArrowExpressionClauseSyntax ExpressionBody + { + get + { + return ExpressionBodyAccessor(this.SyntaxNode); + } + } + + public SyntaxToken SemicolonToken + { + get + { + return SemicolonTokenAccessor(this.SyntaxNode); + } + } + public static explicit operator LocalFunctionStatementSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/NullableDirectiveTriviaSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/NullableDirectiveTriviaSyntaxWrapper.g.cs index 7122c3d6f1..f2fd7c2c04 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/NullableDirectiveTriviaSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/NullableDirectiveTriviaSyntaxWrapper.g.cs @@ -43,6 +43,54 @@ private NullableDirectiveTriviaSyntaxWrapper(DirectiveTriviaSyntax node) } public DirectiveTriviaSyntax SyntaxNode => this.node; + public SyntaxToken HashToken + { + get + { + return this.SyntaxNode.HashToken; + } + } + + public SyntaxToken NullableKeyword + { + get + { + return NullableKeywordAccessor(this.SyntaxNode); + } + } + + public SyntaxToken SettingToken + { + get + { + return SettingTokenAccessor(this.SyntaxNode); + } + } + + public SyntaxToken TargetToken + { + get + { + return TargetTokenAccessor(this.SyntaxNode); + } + } + + public SyntaxToken EndOfDirectiveToken + { + get + { + return this.SyntaxNode.EndOfDirectiveToken; + } + } + + public bool IsActive + { + get + { + return this.SyntaxNode.IsActive; + } + } + public static explicit operator NullableDirectiveTriviaSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedPatternSyntaxWrapper.g.cs index 86521dc4a1..f1631f22fe 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedPatternSyntaxWrapper.g.cs @@ -37,6 +37,30 @@ private ParenthesizedPatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public SyntaxToken OpenParenToken + { + get + { + return OpenParenTokenAccessor(this.SyntaxNode); + } + } + + public PatternSyntaxWrapper Pattern + { + get + { + return (PatternSyntaxWrapper)PatternAccessor(this.SyntaxNode); + } + } + + public SyntaxToken CloseParenToken + { + get + { + return CloseParenTokenAccessor(this.SyntaxNode); + } + } + public static explicit operator ParenthesizedPatternSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedVariableDesignationSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedVariableDesignationSyntaxWrapper.g.cs index a5c0eee129..6e6a5913ab 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedVariableDesignationSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedVariableDesignationSyntaxWrapper.g.cs @@ -37,6 +37,30 @@ private ParenthesizedVariableDesignationSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public SyntaxToken OpenParenToken + { + get + { + return OpenParenTokenAccessor(this.SyntaxNode); + } + } + + public SeparatedSyntaxListWrapper Variables + { + get + { + return VariablesAccessor(this.SyntaxNode); + } + } + + public SyntaxToken CloseParenToken + { + get + { + return CloseParenTokenAccessor(this.SyntaxNode); + } + } + public static explicit operator ParenthesizedVariableDesignationSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PositionalPatternClauseSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PositionalPatternClauseSyntaxWrapper.g.cs index 30a6686f96..04ccba1950 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PositionalPatternClauseSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PositionalPatternClauseSyntaxWrapper.g.cs @@ -37,6 +37,30 @@ private PositionalPatternClauseSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public SyntaxToken OpenParenToken + { + get + { + return OpenParenTokenAccessor(this.SyntaxNode); + } + } + + public SeparatedSyntaxListWrapper Subpatterns + { + get + { + return SubpatternsAccessor(this.SyntaxNode); + } + } + + public SyntaxToken CloseParenToken + { + get + { + return CloseParenTokenAccessor(this.SyntaxNode); + } + } + public static explicit operator PositionalPatternClauseSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PrimaryConstructorBaseTypeSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PrimaryConstructorBaseTypeSyntaxWrapper.g.cs index 843face6c2..6fbb9d6a25 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PrimaryConstructorBaseTypeSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PrimaryConstructorBaseTypeSyntaxWrapper.g.cs @@ -31,6 +31,22 @@ private PrimaryConstructorBaseTypeSyntaxWrapper(BaseTypeSyntax node) } public BaseTypeSyntax SyntaxNode => this.node; + public TypeSyntax Type + { + get + { + return this.SyntaxNode.Type; + } + } + + public ArgumentListSyntax ArgumentList + { + get + { + return ArgumentListAccessor(this.SyntaxNode); + } + } + public static explicit operator PrimaryConstructorBaseTypeSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PropertyPatternClauseSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PropertyPatternClauseSyntaxWrapper.g.cs index 61bb2ce1cf..cb104a92f9 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PropertyPatternClauseSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PropertyPatternClauseSyntaxWrapper.g.cs @@ -37,6 +37,30 @@ private PropertyPatternClauseSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public SyntaxToken OpenBraceToken + { + get + { + return OpenBraceTokenAccessor(this.SyntaxNode); + } + } + + public SeparatedSyntaxListWrapper Subpatterns + { + get + { + return SubpatternsAccessor(this.SyntaxNode); + } + } + + public SyntaxToken CloseBraceToken + { + get + { + return CloseBraceTokenAccessor(this.SyntaxNode); + } + } + public static explicit operator PropertyPatternClauseSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RangeExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RangeExpressionSyntaxWrapper.g.cs index 6614915a1b..cdda148587 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RangeExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RangeExpressionSyntaxWrapper.g.cs @@ -37,6 +37,30 @@ private RangeExpressionSyntaxWrapper(ExpressionSyntax node) } public ExpressionSyntax SyntaxNode => this.node; + public ExpressionSyntax LeftOperand + { + get + { + return LeftOperandAccessor(this.SyntaxNode); + } + } + + public SyntaxToken OperatorToken + { + get + { + return OperatorTokenAccessor(this.SyntaxNode); + } + } + + public ExpressionSyntax RightOperand + { + get + { + return RightOperandAccessor(this.SyntaxNode); + } + } + public static explicit operator RangeExpressionSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecordDeclarationSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecordDeclarationSyntaxWrapper.g.cs index ece5993dba..fa4dcfa5b0 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecordDeclarationSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecordDeclarationSyntaxWrapper.g.cs @@ -51,6 +51,102 @@ private RecordDeclarationSyntaxWrapper(TypeDeclarationSyntax node) } public TypeDeclarationSyntax SyntaxNode => this.node; + public SyntaxList AttributeLists + { + get + { + return this.SyntaxNode.AttributeLists; + } + } + + public SyntaxTokenList Modifiers + { + get + { + return this.SyntaxNode.Modifiers; + } + } + + public SyntaxToken Keyword + { + get + { + return this.SyntaxNode.Keyword; + } + } + + public SyntaxToken Identifier + { + get + { + return this.SyntaxNode.Identifier; + } + } + + public TypeParameterListSyntax TypeParameterList + { + get + { + return this.SyntaxNode.TypeParameterList; + } + } + + public ParameterListSyntax ParameterList + { + get + { + return ParameterListAccessor(this.SyntaxNode); + } + } + + public BaseListSyntax BaseList + { + get + { + return this.SyntaxNode.BaseList; + } + } + + public SyntaxList ConstraintClauses + { + get + { + return this.SyntaxNode.ConstraintClauses; + } + } + + public SyntaxToken OpenBraceToken + { + get + { + return this.SyntaxNode.OpenBraceToken; + } + } + + public SyntaxList Members + { + get + { + return this.SyntaxNode.Members; + } + } + + public SyntaxToken CloseBraceToken + { + get + { + return this.SyntaxNode.CloseBraceToken; + } + } + + public SyntaxToken SemicolonToken + { + get + { + return this.SyntaxNode.SemicolonToken; + } + } + public static explicit operator RecordDeclarationSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecursivePatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecursivePatternSyntaxWrapper.g.cs index edcde76e48..108fb4faaf 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecursivePatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecursivePatternSyntaxWrapper.g.cs @@ -41,6 +41,38 @@ private RecursivePatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public TypeSyntax Type + { + get + { + return TypeAccessor(this.SyntaxNode); + } + } + + public PositionalPatternClauseSyntaxWrapper PositionalPatternClause + { + get + { + return (PositionalPatternClauseSyntaxWrapper)PositionalPatternClauseAccessor(this.SyntaxNode); + } + } + + public PropertyPatternClauseSyntaxWrapper PropertyPatternClause + { + get + { + return (PropertyPatternClauseSyntaxWrapper)PropertyPatternClauseAccessor(this.SyntaxNode); + } + } + + public VariableDesignationSyntaxWrapper Designation + { + get + { + return (VariableDesignationSyntaxWrapper)DesignationAccessor(this.SyntaxNode); + } + } + public static explicit operator RecursivePatternSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefExpressionSyntaxWrapper.g.cs index 7325167cca..e2ec2b9a45 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefExpressionSyntaxWrapper.g.cs @@ -33,6 +33,22 @@ private RefExpressionSyntaxWrapper(ExpressionSyntax node) } public ExpressionSyntax SyntaxNode => this.node; + public SyntaxToken RefKeyword + { + get + { + return RefKeywordAccessor(this.SyntaxNode); + } + } + + public ExpressionSyntax Expression + { + get + { + return ExpressionAccessor(this.SyntaxNode); + } + } + public static explicit operator RefExpressionSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefTypeSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefTypeSyntaxWrapper.g.cs index 0960c162a3..37aa77e94c 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefTypeSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefTypeSyntaxWrapper.g.cs @@ -37,6 +37,30 @@ private RefTypeSyntaxWrapper(TypeSyntax node) } public TypeSyntax SyntaxNode => this.node; + public SyntaxToken RefKeyword + { + get + { + return RefKeywordAccessor(this.SyntaxNode); + } + } + + public SyntaxToken ReadOnlyKeyword + { + get + { + return ReadOnlyKeywordAccessor(this.SyntaxNode); + } + } + + public TypeSyntax Type + { + get + { + return TypeAccessor(this.SyntaxNode); + } + } + public static explicit operator RefTypeSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RelationalPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RelationalPatternSyntaxWrapper.g.cs index 750152b2a6..1be5aa0910 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RelationalPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RelationalPatternSyntaxWrapper.g.cs @@ -33,6 +33,22 @@ private RelationalPatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public SyntaxToken OperatorToken + { + get + { + return OperatorTokenAccessor(this.SyntaxNode); + } + } + + public ExpressionSyntax Expression + { + get + { + return ExpressionAccessor(this.SyntaxNode); + } + } + public static explicit operator RelationalPatternSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SingleVariableDesignationSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SingleVariableDesignationSyntaxWrapper.g.cs index 9db6a16879..10961e8ea3 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SingleVariableDesignationSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SingleVariableDesignationSyntaxWrapper.g.cs @@ -29,6 +29,14 @@ private SingleVariableDesignationSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public SyntaxToken Identifier + { + get + { + return IdentifierAccessor(this.SyntaxNode); + } + } + public static explicit operator SingleVariableDesignationSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SubpatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SubpatternSyntaxWrapper.g.cs index e61747cb2f..cd0921aa9a 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SubpatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SubpatternSyntaxWrapper.g.cs @@ -33,6 +33,22 @@ private SubpatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public NameColonSyntax NameColon + { + get + { + return NameColonAccessor(this.SyntaxNode); + } + } + + public PatternSyntaxWrapper Pattern + { + get + { + return (PatternSyntaxWrapper)PatternAccessor(this.SyntaxNode); + } + } + public static explicit operator SubpatternSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionArmSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionArmSyntaxWrapper.g.cs index cfe71e3779..b53c53ca58 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionArmSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionArmSyntaxWrapper.g.cs @@ -41,6 +41,38 @@ private SwitchExpressionArmSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public PatternSyntaxWrapper Pattern + { + get + { + return (PatternSyntaxWrapper)PatternAccessor(this.SyntaxNode); + } + } + + public WhenClauseSyntaxWrapper WhenClause + { + get + { + return (WhenClauseSyntaxWrapper)WhenClauseAccessor(this.SyntaxNode); + } + } + + public SyntaxToken EqualsGreaterThanToken + { + get + { + return EqualsGreaterThanTokenAccessor(this.SyntaxNode); + } + } + + public ExpressionSyntax Expression + { + get + { + return ExpressionAccessor(this.SyntaxNode); + } + } + public static explicit operator SwitchExpressionArmSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionSyntaxWrapper.g.cs index 6168d1d5ab..36e0d9eb3e 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionSyntaxWrapper.g.cs @@ -45,6 +45,46 @@ private SwitchExpressionSyntaxWrapper(ExpressionSyntax node) } public ExpressionSyntax SyntaxNode => this.node; + public ExpressionSyntax GoverningExpression + { + get + { + return GoverningExpressionAccessor(this.SyntaxNode); + } + } + + public SyntaxToken SwitchKeyword + { + get + { + return SwitchKeywordAccessor(this.SyntaxNode); + } + } + + public SyntaxToken OpenBraceToken + { + get + { + return OpenBraceTokenAccessor(this.SyntaxNode); + } + } + + public SeparatedSyntaxListWrapper Arms + { + get + { + return ArmsAccessor(this.SyntaxNode); + } + } + + public SyntaxToken CloseBraceToken + { + get + { + return CloseBraceTokenAccessor(this.SyntaxNode); + } + } + public static explicit operator SwitchExpressionSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ThrowExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ThrowExpressionSyntaxWrapper.g.cs index 3613a9d11f..38c8441fe2 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ThrowExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ThrowExpressionSyntaxWrapper.g.cs @@ -33,6 +33,22 @@ private ThrowExpressionSyntaxWrapper(ExpressionSyntax node) } public ExpressionSyntax SyntaxNode => this.node; + public SyntaxToken ThrowKeyword + { + get + { + return ThrowKeywordAccessor(this.SyntaxNode); + } + } + + public ExpressionSyntax Expression + { + get + { + return ExpressionAccessor(this.SyntaxNode); + } + } + public static explicit operator ThrowExpressionSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleElementSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleElementSyntaxWrapper.g.cs index a0c514df75..5eda947247 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleElementSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleElementSyntaxWrapper.g.cs @@ -33,6 +33,22 @@ private TupleElementSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public TypeSyntax Type + { + get + { + return TypeAccessor(this.SyntaxNode); + } + } + + public SyntaxToken Identifier + { + get + { + return IdentifierAccessor(this.SyntaxNode); + } + } + public static explicit operator TupleElementSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleExpressionSyntaxWrapper.g.cs index 4d5c5323be..bf1d1e0b3d 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleExpressionSyntaxWrapper.g.cs @@ -37,6 +37,30 @@ private TupleExpressionSyntaxWrapper(ExpressionSyntax node) } public ExpressionSyntax SyntaxNode => this.node; + public SyntaxToken OpenParenToken + { + get + { + return OpenParenTokenAccessor(this.SyntaxNode); + } + } + + public SeparatedSyntaxList Arguments + { + get + { + return ArgumentsAccessor(this.SyntaxNode); + } + } + + public SyntaxToken CloseParenToken + { + get + { + return CloseParenTokenAccessor(this.SyntaxNode); + } + } + public static explicit operator TupleExpressionSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleTypeSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleTypeSyntaxWrapper.g.cs index 36c607430a..61ab682270 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleTypeSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleTypeSyntaxWrapper.g.cs @@ -37,6 +37,30 @@ private TupleTypeSyntaxWrapper(TypeSyntax node) } public TypeSyntax SyntaxNode => this.node; + public SyntaxToken OpenParenToken + { + get + { + return OpenParenTokenAccessor(this.SyntaxNode); + } + } + + public SeparatedSyntaxListWrapper Elements + { + get + { + return ElementsAccessor(this.SyntaxNode); + } + } + + public SyntaxToken CloseParenToken + { + get + { + return CloseParenTokenAccessor(this.SyntaxNode); + } + } + public static explicit operator TupleTypeSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TypePatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TypePatternSyntaxWrapper.g.cs index 6b6162cd9d..f2c2ec7d0c 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TypePatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TypePatternSyntaxWrapper.g.cs @@ -29,6 +29,14 @@ private TypePatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public TypeSyntax Type + { + get + { + return TypeAccessor(this.SyntaxNode); + } + } + public static explicit operator TypePatternSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/UnaryPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/UnaryPatternSyntaxWrapper.g.cs index 684582a272..0638626815 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/UnaryPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/UnaryPatternSyntaxWrapper.g.cs @@ -33,6 +33,22 @@ private UnaryPatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public SyntaxToken OperatorToken + { + get + { + return OperatorTokenAccessor(this.SyntaxNode); + } + } + + public PatternSyntaxWrapper Pattern + { + get + { + return (PatternSyntaxWrapper)PatternAccessor(this.SyntaxNode); + } + } + public static explicit operator UnaryPatternSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VarPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VarPatternSyntaxWrapper.g.cs index 38c7d605e0..1fed48106f 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VarPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VarPatternSyntaxWrapper.g.cs @@ -33,6 +33,22 @@ private VarPatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public SyntaxToken VarKeyword + { + get + { + return VarKeywordAccessor(this.SyntaxNode); + } + } + + public VariableDesignationSyntaxWrapper Designation + { + get + { + return (VariableDesignationSyntaxWrapper)DesignationAccessor(this.SyntaxNode); + } + } + public static explicit operator VarPatternSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WhenClauseSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WhenClauseSyntaxWrapper.g.cs index 8c60bfd62e..f36ba30407 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WhenClauseSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WhenClauseSyntaxWrapper.g.cs @@ -33,6 +33,22 @@ private WhenClauseSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public SyntaxToken WhenKeyword + { + get + { + return WhenKeywordAccessor(this.SyntaxNode); + } + } + + public ExpressionSyntax Condition + { + get + { + return ConditionAccessor(this.SyntaxNode); + } + } + public static explicit operator WhenClauseSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WithExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WithExpressionSyntaxWrapper.g.cs index 130217886b..96b3e5aafb 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WithExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WithExpressionSyntaxWrapper.g.cs @@ -37,6 +37,30 @@ private WithExpressionSyntaxWrapper(ExpressionSyntax node) } public ExpressionSyntax SyntaxNode => this.node; + public ExpressionSyntax Expression + { + get + { + return ExpressionAccessor(this.SyntaxNode); + } + } + + public SyntaxToken WithKeyword + { + get + { + return WithKeywordAccessor(this.SyntaxNode); + } + } + + public InitializerExpressionSyntax Initializer + { + get + { + return InitializerAccessor(this.SyntaxNode); + } + } + public static explicit operator WithExpressionSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CasePatternSwitchLabelSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CasePatternSwitchLabelSyntaxWrapper.cs index 45dcbe4e2b..e4ec03282b 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CasePatternSwitchLabelSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CasePatternSwitchLabelSyntaxWrapper.cs @@ -8,22 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct CasePatternSwitchLabelSyntaxWrapper : ISyntaxWrapper { - public PatternSyntaxWrapper Pattern - { - get - { - return (PatternSyntaxWrapper)PatternAccessor(this.SyntaxNode); - } - } - - public WhenClauseSyntaxWrapper WhenClause - { - get - { - return (WhenClauseSyntaxWrapper)WhenClauseAccessor(this.SyntaxNode); - } - } - public CasePatternSwitchLabelSyntaxWrapper WithKeyword(SyntaxToken keyword) { return new CasePatternSwitchLabelSyntaxWrapper(WithKeywordAccessor(this.SyntaxNode, keyword)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CommonForEachStatementSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CommonForEachStatementSyntaxWrapper.cs index 337be7575b..53bc9a83c1 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CommonForEachStatementSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CommonForEachStatementSyntaxWrapper.cs @@ -10,62 +10,6 @@ internal partial struct CommonForEachStatementSyntaxWrapper : ISyntaxWrapper { - public ExpressionSyntax Expression - { - get - { - return ExpressionAccessor(this.SyntaxNode); - } - } - public static explicit operator ConstantPatternSyntaxWrapper(PatternSyntaxWrapper node) { return (ConstantPatternSyntaxWrapper)node.SyntaxNode; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationExpressionSyntaxWrapper.cs index 6418f43d3b..0e83240be2 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationExpressionSyntaxWrapper.cs @@ -7,22 +7,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct DeclarationExpressionSyntaxWrapper : ISyntaxWrapper { - public TypeSyntax Type - { - get - { - return TypeAccessor(this.SyntaxNode); - } - } - - public VariableDesignationSyntaxWrapper Designation - { - get - { - return (VariableDesignationSyntaxWrapper)DesignationAccessor(this.SyntaxNode); - } - } - public DeclarationExpressionSyntaxWrapper WithType(TypeSyntax type) { return new DeclarationExpressionSyntaxWrapper(WithTypeAccessor(this.SyntaxNode, type)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationPatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationPatternSyntaxWrapper.cs index 32456297dc..a6e4d576ea 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationPatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationPatternSyntaxWrapper.cs @@ -8,22 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct DeclarationPatternSyntaxWrapper : ISyntaxWrapper { - public TypeSyntax Type - { - get - { - return TypeAccessor(this.SyntaxNode); - } - } - - public VariableDesignationSyntaxWrapper Designation - { - get - { - return (VariableDesignationSyntaxWrapper)DesignationAccessor(this.SyntaxNode); - } - } - public static explicit operator DeclarationPatternSyntaxWrapper(PatternSyntaxWrapper node) { return (DeclarationPatternSyntaxWrapper)node.SyntaxNode; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardDesignationSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardDesignationSyntaxWrapper.cs index 490601bc75..ed096ec63e 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardDesignationSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardDesignationSyntaxWrapper.cs @@ -8,14 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct DiscardDesignationSyntaxWrapper : ISyntaxWrapper { - public SyntaxToken UnderscoreToken - { - get - { - return UnderscoreTokenAccessor(this.SyntaxNode); - } - } - public static explicit operator DiscardDesignationSyntaxWrapper(VariableDesignationSyntaxWrapper node) { return (DiscardDesignationSyntaxWrapper)node.SyntaxNode; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardPatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardPatternSyntaxWrapper.cs index 32885dcee4..4d29cce741 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardPatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardPatternSyntaxWrapper.cs @@ -8,14 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct DiscardPatternSyntaxWrapper : ISyntaxWrapper { - public SyntaxToken UnderscoreToken - { - get - { - return UnderscoreTokenAccessor(this.SyntaxNode); - } - } - public static explicit operator DiscardPatternSyntaxWrapper(PatternSyntaxWrapper node) { return (DiscardPatternSyntaxWrapper)node.SyntaxNode; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ForEachVariableStatementSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ForEachVariableStatementSyntaxWrapper.cs index 0ddd4a532c..60179c031b 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ForEachVariableStatementSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ForEachVariableStatementSyntaxWrapper.cs @@ -8,70 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct ForEachVariableStatementSyntaxWrapper : ISyntaxWrapper { - public SyntaxToken AwaitKeyword - { - get - { - return ((CommonForEachStatementSyntaxWrapper)this).AwaitKeyword; - } - } - - public SyntaxToken ForEachKeyword - { - get - { - return ((CommonForEachStatementSyntaxWrapper)this).ForEachKeyword; - } - } - - public SyntaxToken OpenParenToken - { - get - { - return ((CommonForEachStatementSyntaxWrapper)this).OpenParenToken; - } - } - - public ExpressionSyntax Variable - { - get - { - return VariableAccessor(this.SyntaxNode); - } - } - - public SyntaxToken InKeyword - { - get - { - return ((CommonForEachStatementSyntaxWrapper)this).InKeyword; - } - } - - public ExpressionSyntax Expression - { - get - { - return ((CommonForEachStatementSyntaxWrapper)this).Expression; - } - } - - public SyntaxToken CloseParenToken - { - get - { - return ((CommonForEachStatementSyntaxWrapper)this).CloseParenToken; - } - } - - public StatementSyntax Statement - { - get - { - return ((CommonForEachStatementSyntaxWrapper)this).Statement; - } - } - public static explicit operator ForEachVariableStatementSyntaxWrapper(CommonForEachStatementSyntaxWrapper node) { return (ForEachVariableStatementSyntaxWrapper)node.SyntaxNode; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.cs index 1ce960915d..f9b3fe5cda 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.cs @@ -8,38 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct ImplicitStackAllocArrayCreationExpressionSyntaxWrapper : ISyntaxWrapper { - public SyntaxToken StackAllocKeyword - { - get - { - return StackAllocKeywordAccessor(this.SyntaxNode); - } - } - - public SyntaxToken OpenBracketToken - { - get - { - return OpenBracketTokenAccessor(this.SyntaxNode); - } - } - - public SyntaxToken CloseBracketToken - { - get - { - return CloseBracketTokenAccessor(this.SyntaxNode); - } - } - - public InitializerExpressionSyntax Initializer - { - get - { - return InitializerAccessor(this.SyntaxNode); - } - } - public ImplicitStackAllocArrayCreationExpressionSyntaxWrapper WithStackAllocKeyword(SyntaxToken stackAllocKeyword) { return new ImplicitStackAllocArrayCreationExpressionSyntaxWrapper(WithStackAllocKeywordAccessor(this.SyntaxNode, stackAllocKeyword)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/IsPatternExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/IsPatternExpressionSyntaxWrapper.cs index bd63a8effd..f45acbc966 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/IsPatternExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/IsPatternExpressionSyntaxWrapper.cs @@ -8,30 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct IsPatternExpressionSyntaxWrapper : ISyntaxWrapper { - public ExpressionSyntax Expression - { - get - { - return ExpressionAccessor(this.SyntaxNode); - } - } - - public SyntaxToken IsKeyword - { - get - { - return IsKeywordAccessor(this.SyntaxNode); - } - } - - public PatternSyntaxWrapper Pattern - { - get - { - return (PatternSyntaxWrapper)PatternAccessor(this.SyntaxNode); - } - } - public IsPatternExpressionSyntaxWrapper WithExpression(ExpressionSyntax expression) { return new IsPatternExpressionSyntaxWrapper(WithExpressionAccessor(this.SyntaxNode, expression)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/LocalFunctionStatementSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/LocalFunctionStatementSyntaxWrapper.cs index 1b4a4ac6f6..f83f718506 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/LocalFunctionStatementSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/LocalFunctionStatementSyntaxWrapper.cs @@ -9,78 +9,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct LocalFunctionStatementSyntaxWrapper : ISyntaxWrapper { - public SyntaxTokenList Modifiers - { - get - { - return ModifiersAccessor(this.SyntaxNode); - } - } - - public TypeSyntax ReturnType - { - get - { - return ReturnTypeAccessor(this.SyntaxNode); - } - } - - public SyntaxToken Identifier - { - get - { - return IdentifierAccessor(this.SyntaxNode); - } - } - - public TypeParameterListSyntax TypeParameterList - { - get - { - return TypeParameterListAccessor(this.SyntaxNode); - } - } - - public ParameterListSyntax ParameterList - { - get - { - return ParameterListAccessor(this.SyntaxNode); - } - } - - public SyntaxList ConstraintClauses - { - get - { - return ConstraintClausesAccessor(this.SyntaxNode); - } - } - - public BlockSyntax Body - { - get - { - return BodyAccessor(this.SyntaxNode); - } - } - - public ArrowExpressionClauseSyntax ExpressionBody - { - get - { - return ExpressionBodyAccessor(this.SyntaxNode); - } - } - - public SyntaxToken SemicolonToken - { - get - { - return SemicolonTokenAccessor(this.SyntaxNode); - } - } - public LocalFunctionStatementSyntaxWrapper WithModifiers(SyntaxTokenList modifiers) { return new LocalFunctionStatementSyntaxWrapper(WithModifiersAccessor(this.SyntaxNode, modifiers)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ParenthesizedVariableDesignationSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ParenthesizedVariableDesignationSyntaxWrapper.cs index d3b330e406..167b190892 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ParenthesizedVariableDesignationSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ParenthesizedVariableDesignationSyntaxWrapper.cs @@ -8,30 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct ParenthesizedVariableDesignationSyntaxWrapper : ISyntaxWrapper { - public SyntaxToken OpenParenToken - { - get - { - return OpenParenTokenAccessor(this.SyntaxNode); - } - } - - public SeparatedSyntaxListWrapper Variables - { - get - { - return VariablesAccessor(this.SyntaxNode); - } - } - - public SyntaxToken CloseParenToken - { - get - { - return CloseParenTokenAccessor(this.SyntaxNode); - } - } - public static explicit operator ParenthesizedVariableDesignationSyntaxWrapper(VariableDesignationSyntaxWrapper node) { return (ParenthesizedVariableDesignationSyntaxWrapper)node.SyntaxNode; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PositionalPatternClauseSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PositionalPatternClauseSyntaxWrapper.cs index 8e11c68164..de67ecc094 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PositionalPatternClauseSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PositionalPatternClauseSyntaxWrapper.cs @@ -8,30 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct PositionalPatternClauseSyntaxWrapper : ISyntaxWrapper { - public SyntaxToken OpenParenToken - { - get - { - return OpenParenTokenAccessor(this.SyntaxNode); - } - } - - public SeparatedSyntaxListWrapper Subpatterns - { - get - { - return SubpatternsAccessor(this.SyntaxNode); - } - } - - public SyntaxToken CloseParenToken - { - get - { - return CloseParenTokenAccessor(this.SyntaxNode); - } - } - public PositionalPatternClauseSyntaxWrapper AddSubpatterns(params SubpatternSyntaxWrapper[] items) { return new PositionalPatternClauseSyntaxWrapper(this.WithSubpatterns(this.Subpatterns.AddRange(items))); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PropertyPatternClauseSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PropertyPatternClauseSyntaxWrapper.cs index 4b0d73803f..d4e78a49ae 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PropertyPatternClauseSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PropertyPatternClauseSyntaxWrapper.cs @@ -8,30 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct PropertyPatternClauseSyntaxWrapper : ISyntaxWrapper { - public SyntaxToken OpenBraceToken - { - get - { - return OpenBraceTokenAccessor(this.SyntaxNode); - } - } - - public SeparatedSyntaxListWrapper Subpatterns - { - get - { - return SubpatternsAccessor(this.SyntaxNode); - } - } - - public SyntaxToken CloseBraceToken - { - get - { - return CloseBraceTokenAccessor(this.SyntaxNode); - } - } - public PropertyPatternClauseSyntaxWrapper AddSubpatterns(params SubpatternSyntaxWrapper[] items) { return new PropertyPatternClauseSyntaxWrapper(this.WithSubpatterns(this.Subpatterns.AddRange(items))); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RangeExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RangeExpressionSyntaxWrapper.cs index b8234c071d..57845a92e5 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RangeExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RangeExpressionSyntaxWrapper.cs @@ -8,30 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct RangeExpressionSyntaxWrapper : ISyntaxWrapper { - public ExpressionSyntax LeftOperand - { - get - { - return LeftOperandAccessor(this.SyntaxNode); - } - } - - public SyntaxToken OperatorToken - { - get - { - return OperatorTokenAccessor(this.SyntaxNode); - } - } - - public ExpressionSyntax RightOperand - { - get - { - return RightOperandAccessor(this.SyntaxNode); - } - } - public RangeExpressionSyntaxWrapper WithLeftOperand(ExpressionSyntax leftOperand) { return new RangeExpressionSyntaxWrapper(WithLeftOperandAccessor(this.SyntaxNode, leftOperand)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RecursivePatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RecursivePatternSyntaxWrapper.cs index 8d4423627c..6c2be3123c 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RecursivePatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RecursivePatternSyntaxWrapper.cs @@ -8,38 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct RecursivePatternSyntaxWrapper : ISyntaxWrapper { - public TypeSyntax Type - { - get - { - return TypeAccessor(this.SyntaxNode); - } - } - - public PositionalPatternClauseSyntaxWrapper PositionalPatternClause - { - get - { - return (PositionalPatternClauseSyntaxWrapper)PositionalPatternClauseAccessor(this.SyntaxNode); - } - } - - public PropertyPatternClauseSyntaxWrapper PropertyPatternClause - { - get - { - return (PropertyPatternClauseSyntaxWrapper)PropertyPatternClauseAccessor(this.SyntaxNode); - } - } - - public VariableDesignationSyntaxWrapper Designation - { - get - { - return (VariableDesignationSyntaxWrapper)DesignationAccessor(this.SyntaxNode); - } - } - public static explicit operator RecursivePatternSyntaxWrapper(PatternSyntaxWrapper node) { return (RecursivePatternSyntaxWrapper)node.SyntaxNode; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefExpressionSyntaxWrapper.cs index 3e36170b1b..bbc7d65a1d 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefExpressionSyntaxWrapper.cs @@ -8,22 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct RefExpressionSyntaxWrapper : ISyntaxWrapper { - public SyntaxToken RefKeyword - { - get - { - return RefKeywordAccessor(this.SyntaxNode); - } - } - - public ExpressionSyntax Expression - { - get - { - return ExpressionAccessor(this.SyntaxNode); - } - } - public RefExpressionSyntaxWrapper WithRefKeyword(SyntaxToken refKeyword) { return new RefExpressionSyntaxWrapper(WithRefKeywordAccessor(this.SyntaxNode, refKeyword)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefTypeSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefTypeSyntaxWrapper.cs index 8736829403..690b22f73e 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefTypeSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefTypeSyntaxWrapper.cs @@ -8,30 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct RefTypeSyntaxWrapper : ISyntaxWrapper { - public SyntaxToken RefKeyword - { - get - { - return RefKeywordAccessor(this.SyntaxNode); - } - } - - public SyntaxToken ReadOnlyKeyword - { - get - { - return ReadOnlyKeywordAccessor(this.SyntaxNode); - } - } - - public TypeSyntax Type - { - get - { - return TypeAccessor(this.SyntaxNode); - } - } - public RefTypeSyntaxWrapper WithRefKeyword(SyntaxToken refKeyword) { return new RefTypeSyntaxWrapper(WithRefKeywordAccessor(this.SyntaxNode, refKeyword)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SingleVariableDesignationSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SingleVariableDesignationSyntaxWrapper.cs index c4bfe8d099..652d1ee0bb 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SingleVariableDesignationSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SingleVariableDesignationSyntaxWrapper.cs @@ -8,14 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct SingleVariableDesignationSyntaxWrapper : ISyntaxWrapper { - public SyntaxToken Identifier - { - get - { - return IdentifierAccessor(this.SyntaxNode); - } - } - public static explicit operator SingleVariableDesignationSyntaxWrapper(VariableDesignationSyntaxWrapper node) { return (SingleVariableDesignationSyntaxWrapper)node.SyntaxNode; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SubpatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SubpatternSyntaxWrapper.cs index e3734fe6f8..268dcaaa0a 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SubpatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SubpatternSyntaxWrapper.cs @@ -8,22 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct SubpatternSyntaxWrapper : ISyntaxWrapper { - public NameColonSyntax NameColon - { - get - { - return NameColonAccessor(this.SyntaxNode); - } - } - - public PatternSyntaxWrapper Pattern - { - get - { - return (PatternSyntaxWrapper)PatternAccessor(this.SyntaxNode); - } - } - public SubpatternSyntaxWrapper WithNameColon(NameColonSyntax nameColon) { return new SubpatternSyntaxWrapper(WithNameColonAccessor(this.SyntaxNode, nameColon)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionArmSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionArmSyntaxWrapper.cs index 623f1518c1..1872e2bc81 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionArmSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionArmSyntaxWrapper.cs @@ -9,38 +9,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct SwitchExpressionArmSyntaxWrapper : ISyntaxWrapper { - public PatternSyntaxWrapper Pattern - { - get - { - return (PatternSyntaxWrapper)PatternAccessor(this.SyntaxNode); - } - } - - public WhenClauseSyntaxWrapper WhenClause - { - get - { - return (WhenClauseSyntaxWrapper)WhenClauseAccessor(this.SyntaxNode); - } - } - - public ExpressionSyntax Expression - { - get - { - return ExpressionAccessor(this.SyntaxNode); - } - } - - public SyntaxToken EqualsGreaterThanToken - { - get - { - return EqualsGreaterThanTokenAccessor(this.SyntaxNode); - } - } - public SwitchExpressionArmSyntaxWrapper WithPattern(PatternSyntaxWrapper pattern) { return new SwitchExpressionArmSyntaxWrapper(WithPatternAccessor(this.SyntaxNode, pattern.SyntaxNode)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionSyntaxWrapper.cs index b300282a3c..8065658628 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionSyntaxWrapper.cs @@ -8,46 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct SwitchExpressionSyntaxWrapper : ISyntaxWrapper { - public ExpressionSyntax GoverningExpression - { - get - { - return GoverningExpressionAccessor(this.SyntaxNode); - } - } - - public SeparatedSyntaxListWrapper Arms - { - get - { - return ArmsAccessor(this.SyntaxNode); - } - } - - public SyntaxToken OpenBraceToken - { - get - { - return OpenBraceTokenAccessor(this.SyntaxNode); - } - } - - public SyntaxToken SwitchKeyword - { - get - { - return SwitchKeywordAccessor(this.SyntaxNode); - } - } - - public SyntaxToken CloseBraceToken - { - get - { - return CloseBraceTokenAccessor(this.SyntaxNode); - } - } - public SwitchExpressionSyntaxWrapper AddArms(params SwitchExpressionArmSyntaxWrapper[] arms) { return new SwitchExpressionSyntaxWrapper(this.WithArms(this.Arms.AddRange(arms))); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ThrowExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ThrowExpressionSyntaxWrapper.cs index 25cebb2692..5d75ff842f 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ThrowExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ThrowExpressionSyntaxWrapper.cs @@ -8,22 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct ThrowExpressionSyntaxWrapper : ISyntaxWrapper { - public SyntaxToken ThrowKeyword - { - get - { - return ThrowKeywordAccessor(this.SyntaxNode); - } - } - - public ExpressionSyntax Expression - { - get - { - return ExpressionAccessor(this.SyntaxNode); - } - } - public ThrowExpressionSyntaxWrapper WithThrowKeyword(SyntaxToken throwKeyword) { return new ThrowExpressionSyntaxWrapper(WithThrowKeywordAccessor(this.SyntaxNode, throwKeyword)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleElementSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleElementSyntaxWrapper.cs index 04f2cfaa18..19a4069e3d 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleElementSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleElementSyntaxWrapper.cs @@ -9,22 +9,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct TupleElementSyntaxWrapper : ISyntaxWrapper { - public SyntaxToken Identifier - { - get - { - return IdentifierAccessor(this.SyntaxNode); - } - } - - public TypeSyntax Type - { - get - { - return TypeAccessor(this.SyntaxNode); - } - } - public TupleElementSyntaxWrapper WithIdentifier(SyntaxToken identifier) { return new TupleElementSyntaxWrapper(WithIdentifierAccessor(this.SyntaxNode, identifier)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleExpressionSyntaxWrapper.cs index 5001d3cc24..6a1a47a8b8 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleExpressionSyntaxWrapper.cs @@ -8,30 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct TupleExpressionSyntaxWrapper : ISyntaxWrapper { - public SyntaxToken OpenParenToken - { - get - { - return OpenParenTokenAccessor(this.SyntaxNode); - } - } - - public SeparatedSyntaxList Arguments - { - get - { - return ArgumentsAccessor(this.SyntaxNode); - } - } - - public SyntaxToken CloseParenToken - { - get - { - return CloseParenTokenAccessor(this.SyntaxNode); - } - } - public TupleExpressionSyntaxWrapper AddArguments(params ArgumentSyntax[] items) { return new TupleExpressionSyntaxWrapper(this.WithArguments(this.Arguments.AddRange(items))); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleTypeSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleTypeSyntaxWrapper.cs index eff1571018..3a409ed0f4 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleTypeSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleTypeSyntaxWrapper.cs @@ -8,30 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct TupleTypeSyntaxWrapper : ISyntaxWrapper { - public SyntaxToken OpenParenToken - { - get - { - return OpenParenTokenAccessor(this.SyntaxNode); - } - } - - public SeparatedSyntaxListWrapper Elements - { - get - { - return ElementsAccessor(this.SyntaxNode); - } - } - - public SyntaxToken CloseParenToken - { - get - { - return CloseParenTokenAccessor(this.SyntaxNode); - } - } - public TupleTypeSyntaxWrapper AddElements(params TupleElementSyntaxWrapper[] items) { return new TupleTypeSyntaxWrapper(this.WithElements(this.Elements.AddRange(items))); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VarPatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VarPatternSyntaxWrapper.cs index 69694e804c..02a9ba70c6 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VarPatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VarPatternSyntaxWrapper.cs @@ -8,22 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct VarPatternSyntaxWrapper : ISyntaxWrapper { - public SyntaxToken VarKeyword - { - get - { - return VarKeywordAccessor(this.SyntaxNode); - } - } - - public VariableDesignationSyntaxWrapper Designation - { - get - { - return (VariableDesignationSyntaxWrapper)DesignationAccessor(this.SyntaxNode); - } - } - public static explicit operator VarPatternSyntaxWrapper(PatternSyntaxWrapper node) { return (VarPatternSyntaxWrapper)node.SyntaxNode; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/WhenClauseSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/WhenClauseSyntaxWrapper.cs index 4e11040295..3573b5e80a 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/WhenClauseSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/WhenClauseSyntaxWrapper.cs @@ -9,22 +9,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct WhenClauseSyntaxWrapper : ISyntaxWrapper { - public SyntaxToken WhenKeyword - { - get - { - return WhenKeywordAccessor(this.SyntaxNode); - } - } - - public ExpressionSyntax Condition - { - get - { - return ConditionAccessor(this.SyntaxNode); - } - } - public WhenClauseSyntaxWrapper WithWhenKeyword(SyntaxToken whenKeyword) { return new WhenClauseSyntaxWrapper(WithWhenKeywordAccessor(this.SyntaxNode, whenKeyword)); From f28124f0b5883a13e3fb320635c3b86bd1dda00a Mon Sep 17 00:00:00 2001 From: Sam Harwell Date: Tue, 17 Nov 2020 09:00:45 -0800 Subject: [PATCH 13/18] Generate wrapper conversion operators --- .../SyntaxLightupGenerator.cs | 62 +++++++++++++++++++ .../BinaryPatternSyntaxWrapper.g.cs | 20 ++++++ .../ConstantPatternSyntaxWrapper.g.cs | 20 ++++++ .../DeclarationPatternSyntaxWrapper.g.cs | 20 ++++++ .../DiscardDesignationSyntaxWrapper.g.cs | 10 +++ .../DiscardPatternSyntaxWrapper.g.cs | 20 ++++++ ...ForEachVariableStatementSyntaxWrapper.g.cs | 10 +++ ...FunctionPointerParameterSyntaxWrapper.g.cs | 10 +++ ...ObjectCreationExpressionSyntaxWrapper.g.cs | 10 +++ .../ParenthesizedPatternSyntaxWrapper.g.cs | 20 ++++++ ...sizedVariableDesignationSyntaxWrapper.g.cs | 10 +++ .../PatternSyntaxWrapper.g.cs | 10 +++ .../RecursivePatternSyntaxWrapper.g.cs | 20 ++++++ .../RelationalPatternSyntaxWrapper.g.cs | 20 ++++++ ...ingleVariableDesignationSyntaxWrapper.g.cs | 10 +++ .../TypePatternSyntaxWrapper.g.cs | 20 ++++++ .../UnaryPatternSyntaxWrapper.g.cs | 20 ++++++ .../VarPatternSyntaxWrapper.g.cs | 20 ++++++ .../Lightup/ConstantPatternSyntaxWrapper.cs | 10 --- .../DeclarationPatternSyntaxWrapper.cs | 10 --- .../DiscardDesignationSyntaxWrapper.cs | 10 --- .../Lightup/DiscardPatternSyntaxWrapper.cs | 10 --- .../ForEachVariableStatementSyntaxWrapper.cs | 10 --- ...hesizedVariableDesignationSyntaxWrapper.cs | 10 --- .../Lightup/RecursivePatternSyntaxWrapper.cs | 10 --- .../SingleVariableDesignationSyntaxWrapper.cs | 10 --- .../Lightup/VarPatternSyntaxWrapper.cs | 10 --- 27 files changed, 332 insertions(+), 90 deletions(-) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs b/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs index b11bce707c..91c0d2289f 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs @@ -433,6 +433,35 @@ private void GenerateSyntaxWrapper(in GeneratorExecutionContext context, SyntaxD semicolonToken: default)); } + for (var baseNode = syntaxData.TryGetNode(nodeData.BaseName); baseNode?.WrapperName is not null; baseNode = syntaxData.TryGetNode(baseNode.BaseName)) + { + // public static explicit operator SyntaxWrapper(BaseSyntaxWrapper node) + // { + // return (SyntaxWrapper)node.SyntaxNode; + // } + members = members.Add(SyntaxFactory.ConversionOperatorDeclaration( + attributeLists: default, + modifiers: SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword), SyntaxFactory.Token(SyntaxKind.StaticKeyword)), + implicitOrExplicitKeyword: SyntaxFactory.Token(SyntaxKind.ExplicitKeyword), + operatorKeyword: SyntaxFactory.Token(SyntaxKind.OperatorKeyword), + type: SyntaxFactory.IdentifierName(nodeData.WrapperName), + parameterList: SyntaxFactory.ParameterList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Parameter( + attributeLists: default, + modifiers: default, + type: SyntaxFactory.IdentifierName(baseNode.WrapperName), + identifier: SyntaxFactory.Identifier("node"), + @default: null))), + body: SyntaxFactory.Block(SyntaxFactory.ReturnStatement( + SyntaxFactory.CastExpression( + type: SyntaxFactory.IdentifierName(nodeData.WrapperName), + expression: SyntaxFactory.MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + expression: SyntaxFactory.IdentifierName("node"), + name: SyntaxFactory.IdentifierName("SyntaxNode"))))), + expressionBody: null, + semicolonToken: default)); + } + // public static explicit operator WhenClauseSyntaxWrapper(SyntaxNode node) // { // if (node == null) @@ -521,6 +550,39 @@ private void GenerateSyntaxWrapper(in GeneratorExecutionContext context, SyntaxD expressionBody: null, semicolonToken: default)); + for (var baseNode = syntaxData.TryGetNode(nodeData.BaseName); baseNode?.WrapperName is not null; baseNode = syntaxData.TryGetNode(baseNode.BaseName)) + { + // public static implicit operator BaseSyntaxWrapper(SyntaxWrapper wrapper) + // { + // return BaseSyntaxWrapper.FromUpcast(wrapper.node); + // } + members = members.Add(SyntaxFactory.ConversionOperatorDeclaration( + attributeLists: default, + modifiers: SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword), SyntaxFactory.Token(SyntaxKind.StaticKeyword)), + implicitOrExplicitKeyword: SyntaxFactory.Token(SyntaxKind.ImplicitKeyword), + operatorKeyword: SyntaxFactory.Token(SyntaxKind.OperatorKeyword), + type: SyntaxFactory.IdentifierName(baseNode.WrapperName), + parameterList: SyntaxFactory.ParameterList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Parameter( + attributeLists: default, + modifiers: default, + type: SyntaxFactory.IdentifierName(nodeData.WrapperName), + identifier: SyntaxFactory.Identifier("wrapper"), + @default: null))), + body: SyntaxFactory.Block(SyntaxFactory.ReturnStatement( + SyntaxFactory.InvocationExpression( + expression: SyntaxFactory.MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + expression: SyntaxFactory.IdentifierName(baseNode.WrapperName), + name: SyntaxFactory.IdentifierName("FromUpcast")), + argumentList: SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Argument( + SyntaxFactory.MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + expression: SyntaxFactory.IdentifierName("wrapper"), + name: SyntaxFactory.IdentifierName("node")))))))), + expressionBody: null, + semicolonToken: default)); + } + // public static implicit operator CSharpSyntaxNode(SyntaxWrapper wrapper) // { // return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BinaryPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BinaryPatternSyntaxWrapper.g.cs index 1a607301fc..4b89c763fd 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BinaryPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BinaryPatternSyntaxWrapper.g.cs @@ -61,6 +61,16 @@ public PatternSyntaxWrapper Right } } + public static explicit operator BinaryPatternSyntaxWrapper(PatternSyntaxWrapper node) + { + return (BinaryPatternSyntaxWrapper)node.SyntaxNode; + } + + public static explicit operator BinaryPatternSyntaxWrapper(ExpressionOrPatternSyntaxWrapper node) + { + return (BinaryPatternSyntaxWrapper)node.SyntaxNode; + } + public static explicit operator BinaryPatternSyntaxWrapper(SyntaxNode node) { if (node == null) @@ -76,6 +86,16 @@ public static explicit operator BinaryPatternSyntaxWrapper(SyntaxNode node) return new BinaryPatternSyntaxWrapper((CSharpSyntaxNode)node); } + public static implicit operator PatternSyntaxWrapper(BinaryPatternSyntaxWrapper wrapper) + { + return PatternSyntaxWrapper.FromUpcast(wrapper.node); + } + + public static implicit operator ExpressionOrPatternSyntaxWrapper(BinaryPatternSyntaxWrapper wrapper) + { + return ExpressionOrPatternSyntaxWrapper.FromUpcast(wrapper.node); + } + public static implicit operator CSharpSyntaxNode(BinaryPatternSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ConstantPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ConstantPatternSyntaxWrapper.g.cs index 435b4e196a..879eb6afcc 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ConstantPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ConstantPatternSyntaxWrapper.g.cs @@ -37,6 +37,16 @@ public ExpressionSyntax Expression } } + public static explicit operator ConstantPatternSyntaxWrapper(PatternSyntaxWrapper node) + { + return (ConstantPatternSyntaxWrapper)node.SyntaxNode; + } + + public static explicit operator ConstantPatternSyntaxWrapper(ExpressionOrPatternSyntaxWrapper node) + { + return (ConstantPatternSyntaxWrapper)node.SyntaxNode; + } + public static explicit operator ConstantPatternSyntaxWrapper(SyntaxNode node) { if (node == null) @@ -52,6 +62,16 @@ public static explicit operator ConstantPatternSyntaxWrapper(SyntaxNode node) return new ConstantPatternSyntaxWrapper((CSharpSyntaxNode)node); } + public static implicit operator PatternSyntaxWrapper(ConstantPatternSyntaxWrapper wrapper) + { + return PatternSyntaxWrapper.FromUpcast(wrapper.node); + } + + public static implicit operator ExpressionOrPatternSyntaxWrapper(ConstantPatternSyntaxWrapper wrapper) + { + return ExpressionOrPatternSyntaxWrapper.FromUpcast(wrapper.node); + } + public static implicit operator CSharpSyntaxNode(ConstantPatternSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationPatternSyntaxWrapper.g.cs index 029c26bbfb..41bddd547a 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationPatternSyntaxWrapper.g.cs @@ -49,6 +49,16 @@ public VariableDesignationSyntaxWrapper Designation } } + public static explicit operator DeclarationPatternSyntaxWrapper(PatternSyntaxWrapper node) + { + return (DeclarationPatternSyntaxWrapper)node.SyntaxNode; + } + + public static explicit operator DeclarationPatternSyntaxWrapper(ExpressionOrPatternSyntaxWrapper node) + { + return (DeclarationPatternSyntaxWrapper)node.SyntaxNode; + } + public static explicit operator DeclarationPatternSyntaxWrapper(SyntaxNode node) { if (node == null) @@ -64,6 +74,16 @@ public static explicit operator DeclarationPatternSyntaxWrapper(SyntaxNode node) return new DeclarationPatternSyntaxWrapper((CSharpSyntaxNode)node); } + public static implicit operator PatternSyntaxWrapper(DeclarationPatternSyntaxWrapper wrapper) + { + return PatternSyntaxWrapper.FromUpcast(wrapper.node); + } + + public static implicit operator ExpressionOrPatternSyntaxWrapper(DeclarationPatternSyntaxWrapper wrapper) + { + return ExpressionOrPatternSyntaxWrapper.FromUpcast(wrapper.node); + } + public static implicit operator CSharpSyntaxNode(DeclarationPatternSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardDesignationSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardDesignationSyntaxWrapper.g.cs index 244dd72cc7..526c06ac24 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardDesignationSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardDesignationSyntaxWrapper.g.cs @@ -37,6 +37,11 @@ public SyntaxToken UnderscoreToken } } + public static explicit operator DiscardDesignationSyntaxWrapper(VariableDesignationSyntaxWrapper node) + { + return (DiscardDesignationSyntaxWrapper)node.SyntaxNode; + } + public static explicit operator DiscardDesignationSyntaxWrapper(SyntaxNode node) { if (node == null) @@ -52,6 +57,11 @@ public static explicit operator DiscardDesignationSyntaxWrapper(SyntaxNode node) return new DiscardDesignationSyntaxWrapper((CSharpSyntaxNode)node); } + public static implicit operator VariableDesignationSyntaxWrapper(DiscardDesignationSyntaxWrapper wrapper) + { + return VariableDesignationSyntaxWrapper.FromUpcast(wrapper.node); + } + public static implicit operator CSharpSyntaxNode(DiscardDesignationSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardPatternSyntaxWrapper.g.cs index 719cfde137..5075c27267 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardPatternSyntaxWrapper.g.cs @@ -37,6 +37,16 @@ public SyntaxToken UnderscoreToken } } + public static explicit operator DiscardPatternSyntaxWrapper(PatternSyntaxWrapper node) + { + return (DiscardPatternSyntaxWrapper)node.SyntaxNode; + } + + public static explicit operator DiscardPatternSyntaxWrapper(ExpressionOrPatternSyntaxWrapper node) + { + return (DiscardPatternSyntaxWrapper)node.SyntaxNode; + } + public static explicit operator DiscardPatternSyntaxWrapper(SyntaxNode node) { if (node == null) @@ -52,6 +62,16 @@ public static explicit operator DiscardPatternSyntaxWrapper(SyntaxNode node) return new DiscardPatternSyntaxWrapper((CSharpSyntaxNode)node); } + public static implicit operator PatternSyntaxWrapper(DiscardPatternSyntaxWrapper wrapper) + { + return PatternSyntaxWrapper.FromUpcast(wrapper.node); + } + + public static implicit operator ExpressionOrPatternSyntaxWrapper(DiscardPatternSyntaxWrapper wrapper) + { + return ExpressionOrPatternSyntaxWrapper.FromUpcast(wrapper.node); + } + public static implicit operator CSharpSyntaxNode(DiscardPatternSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ForEachVariableStatementSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ForEachVariableStatementSyntaxWrapper.g.cs index 7874523931..41a39be967 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ForEachVariableStatementSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ForEachVariableStatementSyntaxWrapper.g.cs @@ -109,6 +109,11 @@ public StatementSyntax Statement } } + public static explicit operator ForEachVariableStatementSyntaxWrapper(CommonForEachStatementSyntaxWrapper node) + { + return (ForEachVariableStatementSyntaxWrapper)node.SyntaxNode; + } + public static explicit operator ForEachVariableStatementSyntaxWrapper(SyntaxNode node) { if (node == null) @@ -124,6 +129,11 @@ public static explicit operator ForEachVariableStatementSyntaxWrapper(SyntaxNode return new ForEachVariableStatementSyntaxWrapper((StatementSyntax)node); } + public static implicit operator CommonForEachStatementSyntaxWrapper(ForEachVariableStatementSyntaxWrapper wrapper) + { + return CommonForEachStatementSyntaxWrapper.FromUpcast(wrapper.node); + } + public static implicit operator StatementSyntax(ForEachVariableStatementSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterSyntaxWrapper.g.cs index 8aaba4caca..cff256ef0f 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterSyntaxWrapper.g.cs @@ -55,6 +55,11 @@ public TypeSyntax Type } } + public static explicit operator FunctionPointerParameterSyntaxWrapper(BaseParameterSyntaxWrapper node) + { + return (FunctionPointerParameterSyntaxWrapper)node.SyntaxNode; + } + public static explicit operator FunctionPointerParameterSyntaxWrapper(SyntaxNode node) { if (node == null) @@ -70,6 +75,11 @@ public static explicit operator FunctionPointerParameterSyntaxWrapper(SyntaxNode return new FunctionPointerParameterSyntaxWrapper((CSharpSyntaxNode)node); } + public static implicit operator BaseParameterSyntaxWrapper(FunctionPointerParameterSyntaxWrapper wrapper) + { + return BaseParameterSyntaxWrapper.FromUpcast(wrapper.node); + } + public static implicit operator CSharpSyntaxNode(FunctionPointerParameterSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitObjectCreationExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitObjectCreationExpressionSyntaxWrapper.g.cs index 761ae91e0e..0487bfd544 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitObjectCreationExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitObjectCreationExpressionSyntaxWrapper.g.cs @@ -55,6 +55,11 @@ public InitializerExpressionSyntax Initializer } } + public static explicit operator ImplicitObjectCreationExpressionSyntaxWrapper(BaseObjectCreationExpressionSyntaxWrapper node) + { + return (ImplicitObjectCreationExpressionSyntaxWrapper)node.SyntaxNode; + } + public static explicit operator ImplicitObjectCreationExpressionSyntaxWrapper(SyntaxNode node) { if (node == null) @@ -70,6 +75,11 @@ public static explicit operator ImplicitObjectCreationExpressionSyntaxWrapper(Sy return new ImplicitObjectCreationExpressionSyntaxWrapper((ExpressionSyntax)node); } + public static implicit operator BaseObjectCreationExpressionSyntaxWrapper(ImplicitObjectCreationExpressionSyntaxWrapper wrapper) + { + return BaseObjectCreationExpressionSyntaxWrapper.FromUpcast(wrapper.node); + } + public static implicit operator ExpressionSyntax(ImplicitObjectCreationExpressionSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedPatternSyntaxWrapper.g.cs index f1631f22fe..0493c0f731 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedPatternSyntaxWrapper.g.cs @@ -61,6 +61,16 @@ public SyntaxToken CloseParenToken } } + public static explicit operator ParenthesizedPatternSyntaxWrapper(PatternSyntaxWrapper node) + { + return (ParenthesizedPatternSyntaxWrapper)node.SyntaxNode; + } + + public static explicit operator ParenthesizedPatternSyntaxWrapper(ExpressionOrPatternSyntaxWrapper node) + { + return (ParenthesizedPatternSyntaxWrapper)node.SyntaxNode; + } + public static explicit operator ParenthesizedPatternSyntaxWrapper(SyntaxNode node) { if (node == null) @@ -76,6 +86,16 @@ public static explicit operator ParenthesizedPatternSyntaxWrapper(SyntaxNode nod return new ParenthesizedPatternSyntaxWrapper((CSharpSyntaxNode)node); } + public static implicit operator PatternSyntaxWrapper(ParenthesizedPatternSyntaxWrapper wrapper) + { + return PatternSyntaxWrapper.FromUpcast(wrapper.node); + } + + public static implicit operator ExpressionOrPatternSyntaxWrapper(ParenthesizedPatternSyntaxWrapper wrapper) + { + return ExpressionOrPatternSyntaxWrapper.FromUpcast(wrapper.node); + } + public static implicit operator CSharpSyntaxNode(ParenthesizedPatternSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedVariableDesignationSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedVariableDesignationSyntaxWrapper.g.cs index 6e6a5913ab..bbee3c4f9e 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedVariableDesignationSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedVariableDesignationSyntaxWrapper.g.cs @@ -61,6 +61,11 @@ public SyntaxToken CloseParenToken } } + public static explicit operator ParenthesizedVariableDesignationSyntaxWrapper(VariableDesignationSyntaxWrapper node) + { + return (ParenthesizedVariableDesignationSyntaxWrapper)node.SyntaxNode; + } + public static explicit operator ParenthesizedVariableDesignationSyntaxWrapper(SyntaxNode node) { if (node == null) @@ -76,6 +81,11 @@ public static explicit operator ParenthesizedVariableDesignationSyntaxWrapper(Sy return new ParenthesizedVariableDesignationSyntaxWrapper((CSharpSyntaxNode)node); } + public static implicit operator VariableDesignationSyntaxWrapper(ParenthesizedVariableDesignationSyntaxWrapper wrapper) + { + return VariableDesignationSyntaxWrapper.FromUpcast(wrapper.node); + } + public static implicit operator CSharpSyntaxNode(ParenthesizedVariableDesignationSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PatternSyntaxWrapper.g.cs index 16c5a45eec..d3dd7da973 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PatternSyntaxWrapper.g.cs @@ -25,6 +25,11 @@ private PatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static explicit operator PatternSyntaxWrapper(ExpressionOrPatternSyntaxWrapper node) + { + return (PatternSyntaxWrapper)node.SyntaxNode; + } + public static explicit operator PatternSyntaxWrapper(SyntaxNode node) { if (node == null) @@ -40,6 +45,11 @@ public static explicit operator PatternSyntaxWrapper(SyntaxNode node) return new PatternSyntaxWrapper((CSharpSyntaxNode)node); } + public static implicit operator ExpressionOrPatternSyntaxWrapper(PatternSyntaxWrapper wrapper) + { + return ExpressionOrPatternSyntaxWrapper.FromUpcast(wrapper.node); + } + public static implicit operator CSharpSyntaxNode(PatternSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecursivePatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecursivePatternSyntaxWrapper.g.cs index 108fb4faaf..fc6e22697b 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecursivePatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecursivePatternSyntaxWrapper.g.cs @@ -73,6 +73,16 @@ public VariableDesignationSyntaxWrapper Designation } } + public static explicit operator RecursivePatternSyntaxWrapper(PatternSyntaxWrapper node) + { + return (RecursivePatternSyntaxWrapper)node.SyntaxNode; + } + + public static explicit operator RecursivePatternSyntaxWrapper(ExpressionOrPatternSyntaxWrapper node) + { + return (RecursivePatternSyntaxWrapper)node.SyntaxNode; + } + public static explicit operator RecursivePatternSyntaxWrapper(SyntaxNode node) { if (node == null) @@ -88,6 +98,16 @@ public static explicit operator RecursivePatternSyntaxWrapper(SyntaxNode node) return new RecursivePatternSyntaxWrapper((CSharpSyntaxNode)node); } + public static implicit operator PatternSyntaxWrapper(RecursivePatternSyntaxWrapper wrapper) + { + return PatternSyntaxWrapper.FromUpcast(wrapper.node); + } + + public static implicit operator ExpressionOrPatternSyntaxWrapper(RecursivePatternSyntaxWrapper wrapper) + { + return ExpressionOrPatternSyntaxWrapper.FromUpcast(wrapper.node); + } + public static implicit operator CSharpSyntaxNode(RecursivePatternSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RelationalPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RelationalPatternSyntaxWrapper.g.cs index 1be5aa0910..dbbc75d44b 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RelationalPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RelationalPatternSyntaxWrapper.g.cs @@ -49,6 +49,16 @@ public ExpressionSyntax Expression } } + public static explicit operator RelationalPatternSyntaxWrapper(PatternSyntaxWrapper node) + { + return (RelationalPatternSyntaxWrapper)node.SyntaxNode; + } + + public static explicit operator RelationalPatternSyntaxWrapper(ExpressionOrPatternSyntaxWrapper node) + { + return (RelationalPatternSyntaxWrapper)node.SyntaxNode; + } + public static explicit operator RelationalPatternSyntaxWrapper(SyntaxNode node) { if (node == null) @@ -64,6 +74,16 @@ public static explicit operator RelationalPatternSyntaxWrapper(SyntaxNode node) return new RelationalPatternSyntaxWrapper((CSharpSyntaxNode)node); } + public static implicit operator PatternSyntaxWrapper(RelationalPatternSyntaxWrapper wrapper) + { + return PatternSyntaxWrapper.FromUpcast(wrapper.node); + } + + public static implicit operator ExpressionOrPatternSyntaxWrapper(RelationalPatternSyntaxWrapper wrapper) + { + return ExpressionOrPatternSyntaxWrapper.FromUpcast(wrapper.node); + } + public static implicit operator CSharpSyntaxNode(RelationalPatternSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SingleVariableDesignationSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SingleVariableDesignationSyntaxWrapper.g.cs index 10961e8ea3..4651d3bee9 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SingleVariableDesignationSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SingleVariableDesignationSyntaxWrapper.g.cs @@ -37,6 +37,11 @@ public SyntaxToken Identifier } } + public static explicit operator SingleVariableDesignationSyntaxWrapper(VariableDesignationSyntaxWrapper node) + { + return (SingleVariableDesignationSyntaxWrapper)node.SyntaxNode; + } + public static explicit operator SingleVariableDesignationSyntaxWrapper(SyntaxNode node) { if (node == null) @@ -52,6 +57,11 @@ public static explicit operator SingleVariableDesignationSyntaxWrapper(SyntaxNod return new SingleVariableDesignationSyntaxWrapper((CSharpSyntaxNode)node); } + public static implicit operator VariableDesignationSyntaxWrapper(SingleVariableDesignationSyntaxWrapper wrapper) + { + return VariableDesignationSyntaxWrapper.FromUpcast(wrapper.node); + } + public static implicit operator CSharpSyntaxNode(SingleVariableDesignationSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TypePatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TypePatternSyntaxWrapper.g.cs index f2c2ec7d0c..8589b46986 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TypePatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TypePatternSyntaxWrapper.g.cs @@ -37,6 +37,16 @@ public TypeSyntax Type } } + public static explicit operator TypePatternSyntaxWrapper(PatternSyntaxWrapper node) + { + return (TypePatternSyntaxWrapper)node.SyntaxNode; + } + + public static explicit operator TypePatternSyntaxWrapper(ExpressionOrPatternSyntaxWrapper node) + { + return (TypePatternSyntaxWrapper)node.SyntaxNode; + } + public static explicit operator TypePatternSyntaxWrapper(SyntaxNode node) { if (node == null) @@ -52,6 +62,16 @@ public static explicit operator TypePatternSyntaxWrapper(SyntaxNode node) return new TypePatternSyntaxWrapper((CSharpSyntaxNode)node); } + public static implicit operator PatternSyntaxWrapper(TypePatternSyntaxWrapper wrapper) + { + return PatternSyntaxWrapper.FromUpcast(wrapper.node); + } + + public static implicit operator ExpressionOrPatternSyntaxWrapper(TypePatternSyntaxWrapper wrapper) + { + return ExpressionOrPatternSyntaxWrapper.FromUpcast(wrapper.node); + } + public static implicit operator CSharpSyntaxNode(TypePatternSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/UnaryPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/UnaryPatternSyntaxWrapper.g.cs index 0638626815..3300d7302c 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/UnaryPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/UnaryPatternSyntaxWrapper.g.cs @@ -49,6 +49,16 @@ public PatternSyntaxWrapper Pattern } } + public static explicit operator UnaryPatternSyntaxWrapper(PatternSyntaxWrapper node) + { + return (UnaryPatternSyntaxWrapper)node.SyntaxNode; + } + + public static explicit operator UnaryPatternSyntaxWrapper(ExpressionOrPatternSyntaxWrapper node) + { + return (UnaryPatternSyntaxWrapper)node.SyntaxNode; + } + public static explicit operator UnaryPatternSyntaxWrapper(SyntaxNode node) { if (node == null) @@ -64,6 +74,16 @@ public static explicit operator UnaryPatternSyntaxWrapper(SyntaxNode node) return new UnaryPatternSyntaxWrapper((CSharpSyntaxNode)node); } + public static implicit operator PatternSyntaxWrapper(UnaryPatternSyntaxWrapper wrapper) + { + return PatternSyntaxWrapper.FromUpcast(wrapper.node); + } + + public static implicit operator ExpressionOrPatternSyntaxWrapper(UnaryPatternSyntaxWrapper wrapper) + { + return ExpressionOrPatternSyntaxWrapper.FromUpcast(wrapper.node); + } + public static implicit operator CSharpSyntaxNode(UnaryPatternSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VarPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VarPatternSyntaxWrapper.g.cs index 1fed48106f..abe451cfe8 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VarPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VarPatternSyntaxWrapper.g.cs @@ -49,6 +49,16 @@ public VariableDesignationSyntaxWrapper Designation } } + public static explicit operator VarPatternSyntaxWrapper(PatternSyntaxWrapper node) + { + return (VarPatternSyntaxWrapper)node.SyntaxNode; + } + + public static explicit operator VarPatternSyntaxWrapper(ExpressionOrPatternSyntaxWrapper node) + { + return (VarPatternSyntaxWrapper)node.SyntaxNode; + } + public static explicit operator VarPatternSyntaxWrapper(SyntaxNode node) { if (node == null) @@ -64,6 +74,16 @@ public static explicit operator VarPatternSyntaxWrapper(SyntaxNode node) return new VarPatternSyntaxWrapper((CSharpSyntaxNode)node); } + public static implicit operator PatternSyntaxWrapper(VarPatternSyntaxWrapper wrapper) + { + return PatternSyntaxWrapper.FromUpcast(wrapper.node); + } + + public static implicit operator ExpressionOrPatternSyntaxWrapper(VarPatternSyntaxWrapper wrapper) + { + return ExpressionOrPatternSyntaxWrapper.FromUpcast(wrapper.node); + } + public static implicit operator CSharpSyntaxNode(VarPatternSyntaxWrapper wrapper) { return wrapper.node; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ConstantPatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ConstantPatternSyntaxWrapper.cs index 46f90048b4..6281af6bc0 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ConstantPatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ConstantPatternSyntaxWrapper.cs @@ -8,16 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct ConstantPatternSyntaxWrapper : ISyntaxWrapper { - public static explicit operator ConstantPatternSyntaxWrapper(PatternSyntaxWrapper node) - { - return (ConstantPatternSyntaxWrapper)node.SyntaxNode; - } - - public static implicit operator PatternSyntaxWrapper(ConstantPatternSyntaxWrapper wrapper) - { - return PatternSyntaxWrapper.FromUpcast(wrapper.node); - } - public ConstantPatternSyntaxWrapper WithExpression(ExpressionSyntax expression) { return new ConstantPatternSyntaxWrapper(WithExpressionAccessor(this.SyntaxNode, expression)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationPatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationPatternSyntaxWrapper.cs index a6e4d576ea..168ce09de3 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationPatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationPatternSyntaxWrapper.cs @@ -8,16 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct DeclarationPatternSyntaxWrapper : ISyntaxWrapper { - public static explicit operator DeclarationPatternSyntaxWrapper(PatternSyntaxWrapper node) - { - return (DeclarationPatternSyntaxWrapper)node.SyntaxNode; - } - - public static implicit operator PatternSyntaxWrapper(DeclarationPatternSyntaxWrapper wrapper) - { - return PatternSyntaxWrapper.FromUpcast(wrapper.node); - } - public DeclarationPatternSyntaxWrapper WithType(TypeSyntax type) { return new DeclarationPatternSyntaxWrapper(WithTypeAccessor(this.SyntaxNode, type)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardDesignationSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardDesignationSyntaxWrapper.cs index ed096ec63e..410cfc67e7 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardDesignationSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardDesignationSyntaxWrapper.cs @@ -8,16 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct DiscardDesignationSyntaxWrapper : ISyntaxWrapper { - public static explicit operator DiscardDesignationSyntaxWrapper(VariableDesignationSyntaxWrapper node) - { - return (DiscardDesignationSyntaxWrapper)node.SyntaxNode; - } - - public static implicit operator VariableDesignationSyntaxWrapper(DiscardDesignationSyntaxWrapper wrapper) - { - return VariableDesignationSyntaxWrapper.FromUpcast(wrapper.node); - } - public DiscardDesignationSyntaxWrapper WithUnderscoreToken(SyntaxToken identifier) { return new DiscardDesignationSyntaxWrapper(WithUnderscoreTokenAccessor(this.SyntaxNode, identifier)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardPatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardPatternSyntaxWrapper.cs index 4d29cce741..bc026e9d3e 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardPatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardPatternSyntaxWrapper.cs @@ -8,16 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct DiscardPatternSyntaxWrapper : ISyntaxWrapper { - public static explicit operator DiscardPatternSyntaxWrapper(PatternSyntaxWrapper node) - { - return (DiscardPatternSyntaxWrapper)node.SyntaxNode; - } - - public static implicit operator PatternSyntaxWrapper(DiscardPatternSyntaxWrapper wrapper) - { - return PatternSyntaxWrapper.FromUpcast(wrapper.node); - } - public DiscardPatternSyntaxWrapper WithUnderscoreToken(SyntaxToken identifier) { return new DiscardPatternSyntaxWrapper(WithUnderscoreTokenAccessor(this.SyntaxNode, identifier)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ForEachVariableStatementSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ForEachVariableStatementSyntaxWrapper.cs index 60179c031b..b3f29bd32f 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ForEachVariableStatementSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ForEachVariableStatementSyntaxWrapper.cs @@ -8,16 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct ForEachVariableStatementSyntaxWrapper : ISyntaxWrapper { - public static explicit operator ForEachVariableStatementSyntaxWrapper(CommonForEachStatementSyntaxWrapper node) - { - return (ForEachVariableStatementSyntaxWrapper)node.SyntaxNode; - } - - public static implicit operator CommonForEachStatementSyntaxWrapper(ForEachVariableStatementSyntaxWrapper wrapper) - { - return CommonForEachStatementSyntaxWrapper.FromUpcast(wrapper.node); - } - public ForEachVariableStatementSyntaxWrapper WithAwaitKeyword(SyntaxToken awaitKeyword) { return new ForEachVariableStatementSyntaxWrapper(WithAwaitKeywordAccessor(this.SyntaxNode, awaitKeyword)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ParenthesizedVariableDesignationSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ParenthesizedVariableDesignationSyntaxWrapper.cs index 167b190892..e56d256037 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ParenthesizedVariableDesignationSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ParenthesizedVariableDesignationSyntaxWrapper.cs @@ -8,16 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct ParenthesizedVariableDesignationSyntaxWrapper : ISyntaxWrapper { - public static explicit operator ParenthesizedVariableDesignationSyntaxWrapper(VariableDesignationSyntaxWrapper node) - { - return (ParenthesizedVariableDesignationSyntaxWrapper)node.SyntaxNode; - } - - public static implicit operator VariableDesignationSyntaxWrapper(ParenthesizedVariableDesignationSyntaxWrapper wrapper) - { - return VariableDesignationSyntaxWrapper.FromUpcast(wrapper.node); - } - public ParenthesizedVariableDesignationSyntaxWrapper AddVariables(params VariableDesignationSyntaxWrapper[] items) { return new ParenthesizedVariableDesignationSyntaxWrapper(this.WithVariables(this.Variables.AddRange(items))); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RecursivePatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RecursivePatternSyntaxWrapper.cs index 6c2be3123c..cbc1f04046 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RecursivePatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RecursivePatternSyntaxWrapper.cs @@ -8,16 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct RecursivePatternSyntaxWrapper : ISyntaxWrapper { - public static explicit operator RecursivePatternSyntaxWrapper(PatternSyntaxWrapper node) - { - return (RecursivePatternSyntaxWrapper)node.SyntaxNode; - } - - public static implicit operator PatternSyntaxWrapper(RecursivePatternSyntaxWrapper wrapper) - { - return PatternSyntaxWrapper.FromUpcast(wrapper.node); - } - public RecursivePatternSyntaxWrapper AddPositionalPatternClauseSubpatterns(params SubpatternSyntaxWrapper[] items) { var positionalPatternClause = this.PositionalPatternClause; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SingleVariableDesignationSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SingleVariableDesignationSyntaxWrapper.cs index 652d1ee0bb..11b6ae5296 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SingleVariableDesignationSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SingleVariableDesignationSyntaxWrapper.cs @@ -8,16 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct SingleVariableDesignationSyntaxWrapper : ISyntaxWrapper { - public static explicit operator SingleVariableDesignationSyntaxWrapper(VariableDesignationSyntaxWrapper node) - { - return (SingleVariableDesignationSyntaxWrapper)node.SyntaxNode; - } - - public static implicit operator VariableDesignationSyntaxWrapper(SingleVariableDesignationSyntaxWrapper wrapper) - { - return VariableDesignationSyntaxWrapper.FromUpcast(wrapper.node); - } - public SingleVariableDesignationSyntaxWrapper WithIdentifier(SyntaxToken identifier) { return new SingleVariableDesignationSyntaxWrapper(WithIdentifierAccessor(this.SyntaxNode, identifier)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VarPatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VarPatternSyntaxWrapper.cs index 02a9ba70c6..ba3aaf1ea5 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VarPatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VarPatternSyntaxWrapper.cs @@ -8,16 +8,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct VarPatternSyntaxWrapper : ISyntaxWrapper { - public static explicit operator VarPatternSyntaxWrapper(PatternSyntaxWrapper node) - { - return (VarPatternSyntaxWrapper)node.SyntaxNode; - } - - public static implicit operator PatternSyntaxWrapper(VarPatternSyntaxWrapper wrapper) - { - return PatternSyntaxWrapper.FromUpcast(wrapper.node); - } - public VarPatternSyntaxWrapper WithVarKeyword(SyntaxToken varKeyword) { return new VarPatternSyntaxWrapper(WithVarKeywordAccessor(this.SyntaxNode, varKeyword)); From 9473a4cc8c7208d4d334d6dd66f0c2540c1a9eca Mon Sep 17 00:00:00 2001 From: Sam Harwell Date: Tue, 17 Nov 2020 13:37:19 -0800 Subject: [PATCH 14/18] Fix handling of extension fields --- .../SyntaxLightupGenerator.cs | 45 +++++++++++-------- .../CasePatternSwitchLabelSyntaxWrapper.g.cs | 4 +- ...ForEachVariableStatementSyntaxWrapper.g.cs | 24 ++++++---- ...FunctionPointerParameterSyntaxWrapper.g.cs | 6 +-- ...ObjectCreationExpressionSyntaxWrapper.g.cs | 6 +-- .../LocalFunctionStatementSyntaxWrapper.g.cs | 10 ++++- .../NullableDirectiveTriviaSyntaxWrapper.g.cs | 6 +-- ...imaryConstructorBaseTypeSyntaxWrapper.g.cs | 2 +- .../RecordDeclarationSyntaxWrapper.g.cs | 26 +++++------ 9 files changed, 76 insertions(+), 53 deletions(-) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs b/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs index 91c0d2289f..8b6c5afe11 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs @@ -215,7 +215,7 @@ private void GenerateSyntaxWrapper(in GeneratorExecutionContext context, SyntaxD SyntaxFactory.Argument(SyntaxFactory.IdentifierName("WrappedType")), SyntaxFactory.Argument(SyntaxFactory.InvocationExpression( expression: SyntaxFactory.IdentifierName("nameof"), - argumentList: SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Argument(field.GetPropertyNameExpression(syntaxData)))))), + argumentList: SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Argument(SyntaxFactory.IdentifierName(field.Name)))))), })))))); } @@ -269,7 +269,7 @@ private void GenerateSyntaxWrapper(in GeneratorExecutionContext context, SyntaxD SyntaxFactory.Argument(SyntaxFactory.IdentifierName("WrappedType")), SyntaxFactory.Argument(SyntaxFactory.InvocationExpression( expression: SyntaxFactory.IdentifierName("nameof"), - argumentList: SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Argument(field.GetPropertyNameExpression(syntaxData)))))), + argumentList: SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Argument(SyntaxFactory.IdentifierName(field.Name)))))), })))))); } @@ -366,6 +366,14 @@ private void GenerateSyntaxWrapper(in GeneratorExecutionContext context, SyntaxD expression: SyntaxFactory.ThisExpression(), name: SyntaxFactory.IdentifierName("SyntaxNode")), name: SyntaxFactory.IdentifierName(field.Name)); + + if (declaringNode.TryGetField(field.Name) is { IsExtensionField: true }) + { + // this.SyntaxNode.OpenParenToken() + returnExpression = SyntaxFactory.InvocationExpression( + expression: returnExpression, + argumentList: SyntaxFactory.ArgumentList()); + } } } else if (field.IsWrappedSeparatedSyntaxList(syntaxData, out var elementNode)) @@ -1011,10 +1019,10 @@ public NodeData(in GeneratorExecutionContext context, XElement element) this.Name = element.Attribute("Name").Value; - var existingType = context.Compilation.GetTypeByMetadataName($"Microsoft.CodeAnalysis.CSharp.Syntax.{this.Name}") + this.ExistingType = context.Compilation.GetTypeByMetadataName($"Microsoft.CodeAnalysis.CSharp.Syntax.{this.Name}") ?? context.Compilation.GetTypeByMetadataName($"Microsoft.CodeAnalysis.CSharp.{this.Name}") ?? context.Compilation.GetTypeByMetadataName($"Microsoft.CodeAnalysis.{this.Name}"); - if (existingType?.DeclaredAccessibility == Accessibility.Public) + if (this.ExistingType?.DeclaredAccessibility == Accessibility.Public) { this.WrapperName = null; } @@ -1031,6 +1039,8 @@ public NodeData(in GeneratorExecutionContext context, XElement element) public string Name { get; } + public INamedTypeSymbol? ExistingType { get; } + public string? WrapperName { get; } public string BaseName { get; } @@ -1078,6 +1088,18 @@ public FieldData(NodeData nodeData, XElement element) public bool IsOverride { get; } + /// + /// Gets a value indicating whether this field is implemented as an extension method in the lightup layer. + /// + public bool IsExtensionField + { + get + { + return this.nodeData.ExistingType is not null + && this.nodeData.ExistingType.GetMembers(this.Name).IsEmpty; + } + } + public NodeData GetDeclaringNode(SyntaxData syntaxData) { for (var current = this.nodeData; current is not null; current = syntaxData.TryGetNode(current.BaseName)) @@ -1092,21 +1114,6 @@ public NodeData GetDeclaringNode(SyntaxData syntaxData) throw new NotSupportedException("Unable to find declaring node."); } - public NameSyntax GetPropertyNameExpression(SyntaxData syntaxData) - { - var declaringNode = this.GetDeclaringNode(syntaxData); - if (declaringNode == this.nodeData) - { - return SyntaxFactory.IdentifierName(this.Name); - } - else - { - return SyntaxFactory.QualifiedName( - SyntaxFactory.IdentifierName(declaringNode.WrapperName ?? declaringNode.Name), - SyntaxFactory.IdentifierName(this.Name)); - } - } - public bool IsWrappedSeparatedSyntaxList(SyntaxData syntaxData, [NotNullWhen(true)] out NodeData? element) { if (this.Type.StartsWith("SeparatedSyntaxList<") && this.Type.EndsWith(">")) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CasePatternSwitchLabelSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CasePatternSwitchLabelSyntaxWrapper.g.cs index cd2616bda7..34968ed6a0 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CasePatternSwitchLabelSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CasePatternSwitchLabelSyntaxWrapper.g.cs @@ -25,10 +25,10 @@ static CasePatternSwitchLabelSyntaxWrapper() WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(CasePatternSwitchLabelSyntaxWrapper)); PatternAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Pattern)); WhenClauseAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(WhenClause)); - WithKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(SwitchLabelSyntax.Keyword)); + WithKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Keyword)); WithPatternAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Pattern)); WithWhenClauseAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(WhenClause)); - WithColonTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(SwitchLabelSyntax.ColonToken)); + WithColonTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(ColonToken)); } private CasePatternSwitchLabelSyntaxWrapper(SwitchLabelSyntax node) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ForEachVariableStatementSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ForEachVariableStatementSyntaxWrapper.g.cs index 41a39be967..55d378a45f 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ForEachVariableStatementSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ForEachVariableStatementSyntaxWrapper.g.cs @@ -28,15 +28,15 @@ static ForEachVariableStatementSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(ForEachVariableStatementSyntaxWrapper)); VariableAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Variable)); - WithAttributeListsAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor>(WrappedType, nameof(StatementSyntax.AttributeLists)); - WithAwaitKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(CommonForEachStatementSyntaxWrapper.AwaitKeyword)); - WithForEachKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(CommonForEachStatementSyntaxWrapper.ForEachKeyword)); - WithOpenParenTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(CommonForEachStatementSyntaxWrapper.OpenParenToken)); + WithAttributeListsAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor>(WrappedType, nameof(AttributeLists)); + WithAwaitKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(AwaitKeyword)); + WithForEachKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(ForEachKeyword)); + WithOpenParenTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(OpenParenToken)); WithVariableAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Variable)); - WithInKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(CommonForEachStatementSyntaxWrapper.InKeyword)); - WithExpressionAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(CommonForEachStatementSyntaxWrapper.Expression)); - WithCloseParenTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(CommonForEachStatementSyntaxWrapper.CloseParenToken)); - WithStatementAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(CommonForEachStatementSyntaxWrapper.Statement)); + WithInKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(InKeyword)); + WithExpressionAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Expression)); + WithCloseParenTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(CloseParenToken)); + WithStatementAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Statement)); } private ForEachVariableStatementSyntaxWrapper(StatementSyntax node) @@ -45,6 +45,14 @@ private ForEachVariableStatementSyntaxWrapper(StatementSyntax node) } public StatementSyntax SyntaxNode => this.node; + public SyntaxList AttributeLists + { + get + { + return this.SyntaxNode.AttributeLists(); + } + } + public SyntaxToken AwaitKeyword { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterSyntaxWrapper.g.cs index cff256ef0f..2155acb71e 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterSyntaxWrapper.g.cs @@ -20,9 +20,9 @@ namespace StyleCop.Analyzers.Lightup static FunctionPointerParameterSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(FunctionPointerParameterSyntaxWrapper)); - WithAttributeListsAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor>(WrappedType, nameof(BaseParameterSyntaxWrapper.AttributeLists)); - WithModifiersAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(BaseParameterSyntaxWrapper.Modifiers)); - WithTypeAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(BaseParameterSyntaxWrapper.Type)); + WithAttributeListsAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor>(WrappedType, nameof(AttributeLists)); + WithModifiersAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Modifiers)); + WithTypeAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Type)); } private FunctionPointerParameterSyntaxWrapper(CSharpSyntaxNode node) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitObjectCreationExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitObjectCreationExpressionSyntaxWrapper.g.cs index 0487bfd544..3fa9c21476 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitObjectCreationExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitObjectCreationExpressionSyntaxWrapper.g.cs @@ -20,9 +20,9 @@ namespace StyleCop.Analyzers.Lightup static ImplicitObjectCreationExpressionSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(ImplicitObjectCreationExpressionSyntaxWrapper)); - WithNewKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(BaseObjectCreationExpressionSyntaxWrapper.NewKeyword)); - WithArgumentListAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(BaseObjectCreationExpressionSyntaxWrapper.ArgumentList)); - WithInitializerAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(BaseObjectCreationExpressionSyntaxWrapper.Initializer)); + WithNewKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(NewKeyword)); + WithArgumentListAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(ArgumentList)); + WithInitializerAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Initializer)); } private ImplicitObjectCreationExpressionSyntaxWrapper(ExpressionSyntax node) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/LocalFunctionStatementSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/LocalFunctionStatementSyntaxWrapper.g.cs index 0679b0468a..7941b6925b 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/LocalFunctionStatementSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/LocalFunctionStatementSyntaxWrapper.g.cs @@ -45,7 +45,7 @@ static LocalFunctionStatementSyntaxWrapper() BodyAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(Body)); ExpressionBodyAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(ExpressionBody)); SemicolonTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(SemicolonToken)); - WithAttributeListsAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor>(WrappedType, nameof(StatementSyntax.AttributeLists)); + WithAttributeListsAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor>(WrappedType, nameof(AttributeLists)); WithModifiersAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Modifiers)); WithReturnTypeAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(ReturnType)); WithIdentifierAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Identifier)); @@ -63,6 +63,14 @@ private LocalFunctionStatementSyntaxWrapper(StatementSyntax node) } public StatementSyntax SyntaxNode => this.node; + public SyntaxList AttributeLists + { + get + { + return this.SyntaxNode.AttributeLists(); + } + } + public SyntaxTokenList Modifiers { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/NullableDirectiveTriviaSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/NullableDirectiveTriviaSyntaxWrapper.g.cs index f2fd7c2c04..4cab39a1ec 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/NullableDirectiveTriviaSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/NullableDirectiveTriviaSyntaxWrapper.g.cs @@ -29,12 +29,12 @@ static NullableDirectiveTriviaSyntaxWrapper() NullableKeywordAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(NullableKeyword)); SettingTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(SettingToken)); TargetTokenAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(TargetToken)); - WithHashTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(DirectiveTriviaSyntax.HashToken)); + WithHashTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(HashToken)); WithNullableKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(NullableKeyword)); WithSettingTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(SettingToken)); WithTargetTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(TargetToken)); - WithEndOfDirectiveTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(DirectiveTriviaSyntax.EndOfDirectiveToken)); - WithIsActiveAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(DirectiveTriviaSyntax.IsActive)); + WithEndOfDirectiveTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(EndOfDirectiveToken)); + WithIsActiveAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(IsActive)); } private NullableDirectiveTriviaSyntaxWrapper(DirectiveTriviaSyntax node) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PrimaryConstructorBaseTypeSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PrimaryConstructorBaseTypeSyntaxWrapper.g.cs index 6fbb9d6a25..9107b26b16 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PrimaryConstructorBaseTypeSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PrimaryConstructorBaseTypeSyntaxWrapper.g.cs @@ -21,7 +21,7 @@ static PrimaryConstructorBaseTypeSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(PrimaryConstructorBaseTypeSyntaxWrapper)); ArgumentListAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(ArgumentList)); - WithTypeAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(BaseTypeSyntax.Type)); + WithTypeAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Type)); WithArgumentListAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(ArgumentList)); } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecordDeclarationSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecordDeclarationSyntaxWrapper.g.cs index fa4dcfa5b0..30c934a185 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecordDeclarationSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecordDeclarationSyntaxWrapper.g.cs @@ -31,18 +31,18 @@ static RecordDeclarationSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(RecordDeclarationSyntaxWrapper)); ParameterListAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(WrappedType, nameof(ParameterList)); - WithAttributeListsAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor>(WrappedType, nameof(MemberDeclarationSyntax.AttributeLists)); - WithModifiersAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(MemberDeclarationSyntax.Modifiers)); - WithKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(TypeDeclarationSyntax.Keyword)); - WithIdentifierAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(BaseTypeDeclarationSyntax.Identifier)); - WithTypeParameterListAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(TypeDeclarationSyntax.TypeParameterList)); + WithAttributeListsAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor>(WrappedType, nameof(AttributeLists)); + WithModifiersAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Modifiers)); + WithKeywordAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Keyword)); + WithIdentifierAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(Identifier)); + WithTypeParameterListAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(TypeParameterList)); WithParameterListAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(ParameterList)); - WithBaseListAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(BaseTypeDeclarationSyntax.BaseList)); - WithConstraintClausesAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor>(WrappedType, nameof(TypeDeclarationSyntax.ConstraintClauses)); - WithOpenBraceTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(BaseTypeDeclarationSyntax.OpenBraceToken)); - WithMembersAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor>(WrappedType, nameof(TypeDeclarationSyntax.Members)); - WithCloseBraceTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(BaseTypeDeclarationSyntax.CloseBraceToken)); - WithSemicolonTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(BaseTypeDeclarationSyntax.SemicolonToken)); + WithBaseListAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(BaseList)); + WithConstraintClausesAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor>(WrappedType, nameof(ConstraintClauses)); + WithOpenBraceTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(OpenBraceToken)); + WithMembersAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor>(WrappedType, nameof(Members)); + WithCloseBraceTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(CloseBraceToken)); + WithSemicolonTokenAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(WrappedType, nameof(SemicolonToken)); } private RecordDeclarationSyntaxWrapper(TypeDeclarationSyntax node) @@ -55,7 +55,7 @@ public SyntaxList AttributeLists { get { - return this.SyntaxNode.AttributeLists; + return this.SyntaxNode.AttributeLists(); } } @@ -63,7 +63,7 @@ public SyntaxTokenList Modifiers { get { - return this.SyntaxNode.Modifiers; + return this.SyntaxNode.Modifiers(); } } From bca4490c308aab4a4a68ef94ff7876e99908b738 Mon Sep 17 00:00:00 2001 From: Sam Harwell Date: Tue, 17 Nov 2020 13:38:43 -0800 Subject: [PATCH 15/18] Add extension methods for new properties of existing types --- .../MemberDeclarationSyntaxExtensions.cs | 55 +++++++++++++++++++ .../Lightup/StatementSyntaxExtensions.cs | 36 ++++++++++++ 2 files changed, 91 insertions(+) create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/MemberDeclarationSyntaxExtensions.cs create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/StatementSyntaxExtensions.cs diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/MemberDeclarationSyntaxExtensions.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/MemberDeclarationSyntaxExtensions.cs new file mode 100644 index 0000000000..3d195490be --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/MemberDeclarationSyntaxExtensions.cs @@ -0,0 +1,55 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal static class MemberDeclarationSyntaxExtensions + { + private static readonly Func> AttributeListsAccessor; + private static readonly Func ModifiersAccessor; + private static readonly Func, MemberDeclarationSyntax> WithAttributeListsAccessor; + private static readonly Func WithModifiersAccessor; + + static MemberDeclarationSyntaxExtensions() + { + AttributeListsAccessor = LightupHelpers.CreateSyntaxPropertyAccessor>(typeof(MemberDeclarationSyntax), nameof(AttributeLists)); + ModifiersAccessor = LightupHelpers.CreateSyntaxPropertyAccessor(typeof(MemberDeclarationSyntax), nameof(Modifiers)); + WithAttributeListsAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor>(typeof(MemberDeclarationSyntax), nameof(AttributeLists)); + WithModifiersAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor(typeof(MemberDeclarationSyntax), nameof(Modifiers)); + } + + public static SyntaxList AttributeLists(this MemberDeclarationSyntax syntax) + { + return AttributeListsAccessor(syntax); + } + + public static SyntaxTokenList Modifiers(this MemberDeclarationSyntax syntax) + { + return ModifiersAccessor(syntax); + } + + public static MemberDeclarationSyntax WithAttributeLists(this MemberDeclarationSyntax syntax, SyntaxList attributeLists) + { + return WithAttributeListsAccessor(syntax, attributeLists); + } + + public static MemberDeclarationSyntax WithModifiers(this MemberDeclarationSyntax syntax, SyntaxTokenList modifiers) + { + return WithModifiersAccessor(syntax, modifiers); + } + + public static MemberDeclarationSyntax AddAttributeLists(this MemberDeclarationSyntax syntax, params AttributeListSyntax[] items) + { + return syntax.WithAttributeLists(syntax.AttributeLists().AddRange(items)); + } + + public static MemberDeclarationSyntax AddModifiers(this MemberDeclarationSyntax syntax, params SyntaxToken[] items) + { + return syntax.WithModifiers(syntax.Modifiers().AddRange(items)); + } + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/StatementSyntaxExtensions.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/StatementSyntaxExtensions.cs new file mode 100644 index 0000000000..ec95388a97 --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/StatementSyntaxExtensions.cs @@ -0,0 +1,36 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.Lightup +{ + using System; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp.Syntax; + + internal static class StatementSyntaxExtensions + { + private static readonly Func> AttributeListsAccessor; + private static readonly Func, StatementSyntax> WithAttributeListsAccessor; + + static StatementSyntaxExtensions() + { + AttributeListsAccessor = LightupHelpers.CreateSyntaxPropertyAccessor>(typeof(StatementSyntax), nameof(AttributeLists)); + WithAttributeListsAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor>(typeof(StatementSyntax), nameof(AttributeLists)); + } + + public static SyntaxList AttributeLists(this StatementSyntax syntax) + { + return AttributeListsAccessor(syntax); + } + + public static StatementSyntax WithAttributeLists(this StatementSyntax syntax, SyntaxList attributeLists) + { + return WithAttributeListsAccessor(syntax, attributeLists); + } + + public static StatementSyntax AddAttributeLists(this StatementSyntax syntax, params AttributeListSyntax[] items) + { + return syntax.WithAttributeLists(syntax.AttributeLists().AddRange(items)); + } + } +} From 365a26aefa6511783a0afb78f0b0e60eb31fa861 Mon Sep 17 00:00:00 2001 From: Sam Harwell Date: Tue, 17 Nov 2020 17:56:08 -0800 Subject: [PATCH 16/18] Generate With* methods --- .../SyntaxLightupGenerator.cs | 56 +++++++++++++++++ ...ObjectCreationExpressionSyntaxWrapper.g.cs | 15 +++++ .../BaseParameterSyntaxWrapper.g.cs | 15 +++++ .../BinaryPatternSyntaxWrapper.g.cs | 15 +++++ .../CasePatternSwitchLabelSyntaxWrapper.g.cs | 20 +++++++ .../CommonForEachStatementSyntaxWrapper.g.cs | 35 +++++++++++ .../ConstantPatternSyntaxWrapper.g.cs | 5 ++ .../DeclarationExpressionSyntaxWrapper.g.cs | 10 ++++ .../DeclarationPatternSyntaxWrapper.g.cs | 10 ++++ .../DefaultConstraintSyntaxWrapper.g.cs | 5 ++ .../DiscardDesignationSyntaxWrapper.g.cs | 5 ++ .../DiscardPatternSyntaxWrapper.g.cs | 5 ++ ...ForEachVariableStatementSyntaxWrapper.g.cs | 45 ++++++++++++++ ...PointerCallingConventionSyntaxWrapper.g.cs | 10 ++++ ...tionPointerParameterListSyntaxWrapper.g.cs | 15 +++++ ...FunctionPointerParameterSyntaxWrapper.g.cs | 15 +++++ .../FunctionPointerTypeSyntaxWrapper.g.cs | 20 +++++++ ...gedCallingConventionListSyntaxWrapper.g.cs | 15 +++++ ...managedCallingConventionSyntaxWrapper.g.cs | 5 ++ ...ObjectCreationExpressionSyntaxWrapper.g.cs | 15 +++++ ...cArrayCreationExpressionSyntaxWrapper.g.cs | 20 +++++++ .../IsPatternExpressionSyntaxWrapper.g.cs | 15 +++++ .../LocalFunctionStatementSyntaxWrapper.g.cs | 50 ++++++++++++++++ .../NullableDirectiveTriviaSyntaxWrapper.g.cs | 30 ++++++++++ .../ParenthesizedPatternSyntaxWrapper.g.cs | 15 +++++ ...sizedVariableDesignationSyntaxWrapper.g.cs | 15 +++++ .../PositionalPatternClauseSyntaxWrapper.g.cs | 15 +++++ ...imaryConstructorBaseTypeSyntaxWrapper.g.cs | 10 ++++ .../PropertyPatternClauseSyntaxWrapper.g.cs | 15 +++++ .../RangeExpressionSyntaxWrapper.g.cs | 15 +++++ .../RecordDeclarationSyntaxWrapper.g.cs | 60 +++++++++++++++++++ .../RecursivePatternSyntaxWrapper.g.cs | 20 +++++++ .../RefExpressionSyntaxWrapper.g.cs | 10 ++++ .../RefTypeSyntaxWrapper.g.cs | 15 +++++ .../RelationalPatternSyntaxWrapper.g.cs | 10 ++++ ...ingleVariableDesignationSyntaxWrapper.g.cs | 5 ++ .../SubpatternSyntaxWrapper.g.cs | 10 ++++ .../SwitchExpressionArmSyntaxWrapper.g.cs | 20 +++++++ .../SwitchExpressionSyntaxWrapper.g.cs | 25 ++++++++ .../ThrowExpressionSyntaxWrapper.g.cs | 10 ++++ .../TupleElementSyntaxWrapper.g.cs | 10 ++++ .../TupleExpressionSyntaxWrapper.g.cs | 15 +++++ .../TupleTypeSyntaxWrapper.g.cs | 15 +++++ .../TypePatternSyntaxWrapper.g.cs | 5 ++ .../UnaryPatternSyntaxWrapper.g.cs | 10 ++++ .../VarPatternSyntaxWrapper.g.cs | 10 ++++ .../WhenClauseSyntaxWrapper.g.cs | 10 ++++ .../WithExpressionSyntaxWrapper.g.cs | 15 +++++ .../CasePatternSwitchLabelSyntaxWrapper.cs | 31 ---------- .../CommonForEachStatementSyntaxWrapper.cs | 36 ----------- .../Lightup/ConstantPatternSyntaxWrapper.cs | 16 ----- .../DeclarationExpressionSyntaxWrapper.cs | 20 ------- .../DeclarationPatternSyntaxWrapper.cs | 21 ------- .../DiscardDesignationSyntaxWrapper.cs | 16 ----- .../Lightup/DiscardPatternSyntaxWrapper.cs | 16 ----- .../ForEachVariableStatementSyntaxWrapper.cs | 51 ---------------- ...locArrayCreationExpressionSyntaxWrapper.cs | 21 ------- .../IsPatternExpressionSyntaxWrapper.cs | 26 -------- .../LocalFunctionStatementSyntaxWrapper.cs | 45 -------------- ...hesizedVariableDesignationSyntaxWrapper.cs | 16 ----- .../PositionalPatternClauseSyntaxWrapper.cs | 16 ----- .../PropertyPatternClauseSyntaxWrapper.cs | 16 ----- .../Lightup/RangeExpressionSyntaxWrapper.cs | 26 -------- .../Lightup/RecursivePatternSyntaxWrapper.cs | 21 ------- .../Lightup/RefExpressionSyntaxWrapper.cs | 21 ------- .../Lightup/RefTypeSyntaxWrapper.cs | 26 -------- .../SingleVariableDesignationSyntaxWrapper.cs | 16 ----- .../Lightup/SubpatternSyntaxWrapper.cs | 21 ------- .../SwitchExpressionArmSyntaxWrapper.cs | 32 ---------- .../Lightup/SwitchExpressionSyntaxWrapper.cs | 26 -------- .../Lightup/ThrowExpressionSyntaxWrapper.cs | 21 ------- .../Lightup/TupleElementSyntaxWrapper.cs | 22 ------- .../Lightup/TupleExpressionSyntaxWrapper.cs | 16 ----- .../Lightup/TupleTypeSyntaxWrapper.cs | 16 ----- .../Lightup/VarPatternSyntaxWrapper.cs | 21 ------- .../Lightup/WhenClauseSyntaxWrapper.cs | 22 ------- 76 files changed, 811 insertions(+), 654 deletions(-) delete mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CasePatternSwitchLabelSyntaxWrapper.cs delete mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ConstantPatternSyntaxWrapper.cs delete mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationExpressionSyntaxWrapper.cs delete mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationPatternSyntaxWrapper.cs delete mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardDesignationSyntaxWrapper.cs delete mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardPatternSyntaxWrapper.cs delete mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ForEachVariableStatementSyntaxWrapper.cs delete mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/IsPatternExpressionSyntaxWrapper.cs delete mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RangeExpressionSyntaxWrapper.cs delete mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefExpressionSyntaxWrapper.cs delete mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefTypeSyntaxWrapper.cs delete mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SingleVariableDesignationSyntaxWrapper.cs delete mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SubpatternSyntaxWrapper.cs delete mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionArmSyntaxWrapper.cs delete mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ThrowExpressionSyntaxWrapper.cs delete mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleElementSyntaxWrapper.cs delete mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VarPatternSyntaxWrapper.cs delete mode 100644 StyleCop.Analyzers/StyleCop.Analyzers/Lightup/WhenClauseSyntaxWrapper.cs diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs b/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs index 8b6c5afe11..a03fc7d926 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs @@ -652,6 +652,62 @@ private void GenerateSyntaxWrapper(in GeneratorExecutionContext context, SyntaxD })))))), expressionBody: null)); + foreach (var field in nodeData.Fields) + { + if (field.IsSkipped) + { + continue; + } + + string valueName = char.ToLowerInvariant(field.Name[0]) + field.Name.Substring(1); + + ExpressionSyntax convertedValue = SyntaxFactory.IdentifierName(valueName); + + TypeSyntax propertyType = SyntaxFactory.ParseTypeName(field.GetAccessorResultType(syntaxData)); + if (syntaxData.TryGetNode(field.Type) is { WrapperName: { } wrapperName }) + { + propertyType = SyntaxFactory.IdentifierName(wrapperName); + } + + ExpressionSyntax returnExpression = SyntaxFactory.InvocationExpression( + expression: SyntaxFactory.IdentifierName(field.WithAccessorName), + argumentList: SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList( + new[] + { + SyntaxFactory.Argument(SyntaxFactory.MemberAccessExpression( + SyntaxKind.SimpleMemberAccessExpression, + expression: SyntaxFactory.ThisExpression(), + name: SyntaxFactory.IdentifierName("SyntaxNode"))), + SyntaxFactory.Argument(convertedValue), + }))); + + // public SyntaxWrapper WithField(T value) + // { + // return new SyntaxWrapper(...); + // } + members = members.Add(SyntaxFactory.MethodDeclaration( + attributeLists: default, + modifiers: SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword)), + returnType: SyntaxFactory.IdentifierName(nodeData.WrapperName), + explicitInterfaceSpecifier: null, + identifier: SyntaxFactory.Identifier("With" + field.Name), + typeParameterList: null, + parameterList: SyntaxFactory.ParameterList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Parameter( + attributeLists: default, + modifiers: default, + type: propertyType, + identifier: SyntaxFactory.Identifier(valueName), + @default: null))), + constraintClauses: default, + body: SyntaxFactory.Block(SyntaxFactory.ReturnStatement( + SyntaxFactory.ObjectCreationExpression( + type: SyntaxFactory.IdentifierName(nodeData.WrapperName), + argumentList: SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Argument(returnExpression))), + initializer: null))), + expressionBody: null, + semicolonToken: default)); + } + if (nodeData.Kind == NodeKind.Abstract) { // internal static SyntaxWrapper FromUpcast(CSharpSyntaxNode node) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseObjectCreationExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseObjectCreationExpressionSyntaxWrapper.g.cs index 240fc473de..09f028b174 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseObjectCreationExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseObjectCreationExpressionSyntaxWrapper.g.cs @@ -86,6 +86,21 @@ public static bool IsInstance(SyntaxNode node) return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + public BaseObjectCreationExpressionSyntaxWrapper WithNewKeyword(SyntaxToken newKeyword) + { + return new BaseObjectCreationExpressionSyntaxWrapper(WithNewKeywordAccessor(this.SyntaxNode, newKeyword)); + } + + public BaseObjectCreationExpressionSyntaxWrapper WithArgumentList(ArgumentListSyntax argumentList) + { + return new BaseObjectCreationExpressionSyntaxWrapper(WithArgumentListAccessor(this.SyntaxNode, argumentList)); + } + + public BaseObjectCreationExpressionSyntaxWrapper WithInitializer(InitializerExpressionSyntax initializer) + { + return new BaseObjectCreationExpressionSyntaxWrapper(WithInitializerAccessor(this.SyntaxNode, initializer)); + } + internal static BaseObjectCreationExpressionSyntaxWrapper FromUpcast(ExpressionSyntax node) { return new BaseObjectCreationExpressionSyntaxWrapper(node); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseParameterSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseParameterSyntaxWrapper.g.cs index 6aaa8832c1..a063ac1f6e 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseParameterSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseParameterSyntaxWrapper.g.cs @@ -86,6 +86,21 @@ public static bool IsInstance(SyntaxNode node) return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + public BaseParameterSyntaxWrapper WithAttributeLists(SyntaxList attributeLists) + { + return new BaseParameterSyntaxWrapper(WithAttributeListsAccessor(this.SyntaxNode, attributeLists)); + } + + public BaseParameterSyntaxWrapper WithModifiers(SyntaxTokenList modifiers) + { + return new BaseParameterSyntaxWrapper(WithModifiersAccessor(this.SyntaxNode, modifiers)); + } + + public BaseParameterSyntaxWrapper WithType(TypeSyntax type) + { + return new BaseParameterSyntaxWrapper(WithTypeAccessor(this.SyntaxNode, type)); + } + internal static BaseParameterSyntaxWrapper FromUpcast(CSharpSyntaxNode node) { return new BaseParameterSyntaxWrapper(node); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BinaryPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BinaryPatternSyntaxWrapper.g.cs index 4b89c763fd..2ea835a418 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BinaryPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BinaryPatternSyntaxWrapper.g.cs @@ -105,5 +105,20 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + public BinaryPatternSyntaxWrapper WithLeft(PatternSyntaxWrapper left) + { + return new BinaryPatternSyntaxWrapper(WithLeftAccessor(this.SyntaxNode, left)); + } + + public BinaryPatternSyntaxWrapper WithOperatorToken(SyntaxToken operatorToken) + { + return new BinaryPatternSyntaxWrapper(WithOperatorTokenAccessor(this.SyntaxNode, operatorToken)); + } + + public BinaryPatternSyntaxWrapper WithRight(PatternSyntaxWrapper right) + { + return new BinaryPatternSyntaxWrapper(WithRightAccessor(this.SyntaxNode, right)); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CasePatternSwitchLabelSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CasePatternSwitchLabelSyntaxWrapper.g.cs index 34968ed6a0..f6c6405a43 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CasePatternSwitchLabelSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CasePatternSwitchLabelSyntaxWrapper.g.cs @@ -93,5 +93,25 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + public CasePatternSwitchLabelSyntaxWrapper WithKeyword(SyntaxToken keyword) + { + return new CasePatternSwitchLabelSyntaxWrapper(WithKeywordAccessor(this.SyntaxNode, keyword)); + } + + public CasePatternSwitchLabelSyntaxWrapper WithPattern(PatternSyntaxWrapper pattern) + { + return new CasePatternSwitchLabelSyntaxWrapper(WithPatternAccessor(this.SyntaxNode, pattern)); + } + + public CasePatternSwitchLabelSyntaxWrapper WithWhenClause(WhenClauseSyntaxWrapper whenClause) + { + return new CasePatternSwitchLabelSyntaxWrapper(WithWhenClauseAccessor(this.SyntaxNode, whenClause)); + } + + public CasePatternSwitchLabelSyntaxWrapper WithColonToken(SyntaxToken colonToken) + { + return new CasePatternSwitchLabelSyntaxWrapper(WithColonTokenAccessor(this.SyntaxNode, colonToken)); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CommonForEachStatementSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CommonForEachStatementSyntaxWrapper.g.cs index 5026e6ff5b..1ef7d1d26b 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CommonForEachStatementSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CommonForEachStatementSyntaxWrapper.g.cs @@ -134,6 +134,41 @@ public static bool IsInstance(SyntaxNode node) return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + public CommonForEachStatementSyntaxWrapper WithAwaitKeyword(SyntaxToken awaitKeyword) + { + return new CommonForEachStatementSyntaxWrapper(WithAwaitKeywordAccessor(this.SyntaxNode, awaitKeyword)); + } + + public CommonForEachStatementSyntaxWrapper WithForEachKeyword(SyntaxToken forEachKeyword) + { + return new CommonForEachStatementSyntaxWrapper(WithForEachKeywordAccessor(this.SyntaxNode, forEachKeyword)); + } + + public CommonForEachStatementSyntaxWrapper WithOpenParenToken(SyntaxToken openParenToken) + { + return new CommonForEachStatementSyntaxWrapper(WithOpenParenTokenAccessor(this.SyntaxNode, openParenToken)); + } + + public CommonForEachStatementSyntaxWrapper WithInKeyword(SyntaxToken inKeyword) + { + return new CommonForEachStatementSyntaxWrapper(WithInKeywordAccessor(this.SyntaxNode, inKeyword)); + } + + public CommonForEachStatementSyntaxWrapper WithExpression(ExpressionSyntax expression) + { + return new CommonForEachStatementSyntaxWrapper(WithExpressionAccessor(this.SyntaxNode, expression)); + } + + public CommonForEachStatementSyntaxWrapper WithCloseParenToken(SyntaxToken closeParenToken) + { + return new CommonForEachStatementSyntaxWrapper(WithCloseParenTokenAccessor(this.SyntaxNode, closeParenToken)); + } + + public CommonForEachStatementSyntaxWrapper WithStatement(StatementSyntax statement) + { + return new CommonForEachStatementSyntaxWrapper(WithStatementAccessor(this.SyntaxNode, statement)); + } + internal static CommonForEachStatementSyntaxWrapper FromUpcast(StatementSyntax node) { return new CommonForEachStatementSyntaxWrapper(node); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ConstantPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ConstantPatternSyntaxWrapper.g.cs index 879eb6afcc..a654a76471 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ConstantPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ConstantPatternSyntaxWrapper.g.cs @@ -81,5 +81,10 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + public ConstantPatternSyntaxWrapper WithExpression(ExpressionSyntax expression) + { + return new ConstantPatternSyntaxWrapper(WithExpressionAccessor(this.SyntaxNode, expression)); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationExpressionSyntaxWrapper.g.cs index f2a3cb40cf..05faf453e0 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationExpressionSyntaxWrapper.g.cs @@ -73,5 +73,15 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + public DeclarationExpressionSyntaxWrapper WithType(TypeSyntax type) + { + return new DeclarationExpressionSyntaxWrapper(WithTypeAccessor(this.SyntaxNode, type)); + } + + public DeclarationExpressionSyntaxWrapper WithDesignation(VariableDesignationSyntaxWrapper designation) + { + return new DeclarationExpressionSyntaxWrapper(WithDesignationAccessor(this.SyntaxNode, designation)); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationPatternSyntaxWrapper.g.cs index 41bddd547a..0b965518a6 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationPatternSyntaxWrapper.g.cs @@ -93,5 +93,15 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + public DeclarationPatternSyntaxWrapper WithType(TypeSyntax type) + { + return new DeclarationPatternSyntaxWrapper(WithTypeAccessor(this.SyntaxNode, type)); + } + + public DeclarationPatternSyntaxWrapper WithDesignation(VariableDesignationSyntaxWrapper designation) + { + return new DeclarationPatternSyntaxWrapper(WithDesignationAccessor(this.SyntaxNode, designation)); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DefaultConstraintSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DefaultConstraintSyntaxWrapper.g.cs index 0e951fb067..a1a1b9f6ba 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DefaultConstraintSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DefaultConstraintSyntaxWrapper.g.cs @@ -61,5 +61,10 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + public DefaultConstraintSyntaxWrapper WithDefaultKeyword(SyntaxToken defaultKeyword) + { + return new DefaultConstraintSyntaxWrapper(WithDefaultKeywordAccessor(this.SyntaxNode, defaultKeyword)); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardDesignationSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardDesignationSyntaxWrapper.g.cs index 526c06ac24..3ec19a92cd 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardDesignationSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardDesignationSyntaxWrapper.g.cs @@ -71,5 +71,10 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + public DiscardDesignationSyntaxWrapper WithUnderscoreToken(SyntaxToken underscoreToken) + { + return new DiscardDesignationSyntaxWrapper(WithUnderscoreTokenAccessor(this.SyntaxNode, underscoreToken)); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardPatternSyntaxWrapper.g.cs index 5075c27267..3a62aabb74 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardPatternSyntaxWrapper.g.cs @@ -81,5 +81,10 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + public DiscardPatternSyntaxWrapper WithUnderscoreToken(SyntaxToken underscoreToken) + { + return new DiscardPatternSyntaxWrapper(WithUnderscoreTokenAccessor(this.SyntaxNode, underscoreToken)); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ForEachVariableStatementSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ForEachVariableStatementSyntaxWrapper.g.cs index 55d378a45f..fc36797243 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ForEachVariableStatementSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ForEachVariableStatementSyntaxWrapper.g.cs @@ -151,5 +151,50 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + public ForEachVariableStatementSyntaxWrapper WithAttributeLists(SyntaxList attributeLists) + { + return new ForEachVariableStatementSyntaxWrapper(WithAttributeListsAccessor(this.SyntaxNode, attributeLists)); + } + + public ForEachVariableStatementSyntaxWrapper WithAwaitKeyword(SyntaxToken awaitKeyword) + { + return new ForEachVariableStatementSyntaxWrapper(WithAwaitKeywordAccessor(this.SyntaxNode, awaitKeyword)); + } + + public ForEachVariableStatementSyntaxWrapper WithForEachKeyword(SyntaxToken forEachKeyword) + { + return new ForEachVariableStatementSyntaxWrapper(WithForEachKeywordAccessor(this.SyntaxNode, forEachKeyword)); + } + + public ForEachVariableStatementSyntaxWrapper WithOpenParenToken(SyntaxToken openParenToken) + { + return new ForEachVariableStatementSyntaxWrapper(WithOpenParenTokenAccessor(this.SyntaxNode, openParenToken)); + } + + public ForEachVariableStatementSyntaxWrapper WithVariable(ExpressionSyntax variable) + { + return new ForEachVariableStatementSyntaxWrapper(WithVariableAccessor(this.SyntaxNode, variable)); + } + + public ForEachVariableStatementSyntaxWrapper WithInKeyword(SyntaxToken inKeyword) + { + return new ForEachVariableStatementSyntaxWrapper(WithInKeywordAccessor(this.SyntaxNode, inKeyword)); + } + + public ForEachVariableStatementSyntaxWrapper WithExpression(ExpressionSyntax expression) + { + return new ForEachVariableStatementSyntaxWrapper(WithExpressionAccessor(this.SyntaxNode, expression)); + } + + public ForEachVariableStatementSyntaxWrapper WithCloseParenToken(SyntaxToken closeParenToken) + { + return new ForEachVariableStatementSyntaxWrapper(WithCloseParenTokenAccessor(this.SyntaxNode, closeParenToken)); + } + + public ForEachVariableStatementSyntaxWrapper WithStatement(StatementSyntax statement) + { + return new ForEachVariableStatementSyntaxWrapper(WithStatementAccessor(this.SyntaxNode, statement)); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerCallingConventionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerCallingConventionSyntaxWrapper.g.cs index 270ab8c88d..52caa13bbc 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerCallingConventionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerCallingConventionSyntaxWrapper.g.cs @@ -73,5 +73,15 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + public FunctionPointerCallingConventionSyntaxWrapper WithManagedOrUnmanagedKeyword(SyntaxToken managedOrUnmanagedKeyword) + { + return new FunctionPointerCallingConventionSyntaxWrapper(WithManagedOrUnmanagedKeywordAccessor(this.SyntaxNode, managedOrUnmanagedKeyword)); + } + + public FunctionPointerCallingConventionSyntaxWrapper WithUnmanagedCallingConventionList(FunctionPointerUnmanagedCallingConventionListSyntaxWrapper unmanagedCallingConventionList) + { + return new FunctionPointerCallingConventionSyntaxWrapper(WithUnmanagedCallingConventionListAccessor(this.SyntaxNode, unmanagedCallingConventionList)); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterListSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterListSyntaxWrapper.g.cs index 7f59ceb57e..76f685cf2a 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterListSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterListSyntaxWrapper.g.cs @@ -85,5 +85,20 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + public FunctionPointerParameterListSyntaxWrapper WithLessThanToken(SyntaxToken lessThanToken) + { + return new FunctionPointerParameterListSyntaxWrapper(WithLessThanTokenAccessor(this.SyntaxNode, lessThanToken)); + } + + public FunctionPointerParameterListSyntaxWrapper WithParameters(SeparatedSyntaxListWrapper parameters) + { + return new FunctionPointerParameterListSyntaxWrapper(WithParametersAccessor(this.SyntaxNode, parameters)); + } + + public FunctionPointerParameterListSyntaxWrapper WithGreaterThanToken(SyntaxToken greaterThanToken) + { + return new FunctionPointerParameterListSyntaxWrapper(WithGreaterThanTokenAccessor(this.SyntaxNode, greaterThanToken)); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterSyntaxWrapper.g.cs index 2155acb71e..564e70d5d9 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterSyntaxWrapper.g.cs @@ -89,5 +89,20 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + public FunctionPointerParameterSyntaxWrapper WithAttributeLists(SyntaxList attributeLists) + { + return new FunctionPointerParameterSyntaxWrapper(WithAttributeListsAccessor(this.SyntaxNode, attributeLists)); + } + + public FunctionPointerParameterSyntaxWrapper WithModifiers(SyntaxTokenList modifiers) + { + return new FunctionPointerParameterSyntaxWrapper(WithModifiersAccessor(this.SyntaxNode, modifiers)); + } + + public FunctionPointerParameterSyntaxWrapper WithType(TypeSyntax type) + { + return new FunctionPointerParameterSyntaxWrapper(WithTypeAccessor(this.SyntaxNode, type)); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerTypeSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerTypeSyntaxWrapper.g.cs index 23a1266759..908a1994e7 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerTypeSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerTypeSyntaxWrapper.g.cs @@ -97,5 +97,25 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + public FunctionPointerTypeSyntaxWrapper WithDelegateKeyword(SyntaxToken delegateKeyword) + { + return new FunctionPointerTypeSyntaxWrapper(WithDelegateKeywordAccessor(this.SyntaxNode, delegateKeyword)); + } + + public FunctionPointerTypeSyntaxWrapper WithAsteriskToken(SyntaxToken asteriskToken) + { + return new FunctionPointerTypeSyntaxWrapper(WithAsteriskTokenAccessor(this.SyntaxNode, asteriskToken)); + } + + public FunctionPointerTypeSyntaxWrapper WithCallingConvention(FunctionPointerCallingConventionSyntaxWrapper callingConvention) + { + return new FunctionPointerTypeSyntaxWrapper(WithCallingConventionAccessor(this.SyntaxNode, callingConvention)); + } + + public FunctionPointerTypeSyntaxWrapper WithParameterList(FunctionPointerParameterListSyntaxWrapper parameterList) + { + return new FunctionPointerTypeSyntaxWrapper(WithParameterListAccessor(this.SyntaxNode, parameterList)); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionListSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionListSyntaxWrapper.g.cs index 415075fb33..341fd376aa 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionListSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionListSyntaxWrapper.g.cs @@ -85,5 +85,20 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + public FunctionPointerUnmanagedCallingConventionListSyntaxWrapper WithOpenBracketToken(SyntaxToken openBracketToken) + { + return new FunctionPointerUnmanagedCallingConventionListSyntaxWrapper(WithOpenBracketTokenAccessor(this.SyntaxNode, openBracketToken)); + } + + public FunctionPointerUnmanagedCallingConventionListSyntaxWrapper WithCallingConventions(SeparatedSyntaxListWrapper callingConventions) + { + return new FunctionPointerUnmanagedCallingConventionListSyntaxWrapper(WithCallingConventionsAccessor(this.SyntaxNode, callingConventions)); + } + + public FunctionPointerUnmanagedCallingConventionListSyntaxWrapper WithCloseBracketToken(SyntaxToken closeBracketToken) + { + return new FunctionPointerUnmanagedCallingConventionListSyntaxWrapper(WithCloseBracketTokenAccessor(this.SyntaxNode, closeBracketToken)); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionSyntaxWrapper.g.cs index 712e3dfb35..cd800d6989 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionSyntaxWrapper.g.cs @@ -61,5 +61,10 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + public FunctionPointerUnmanagedCallingConventionSyntaxWrapper WithName(SyntaxToken name) + { + return new FunctionPointerUnmanagedCallingConventionSyntaxWrapper(WithNameAccessor(this.SyntaxNode, name)); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitObjectCreationExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitObjectCreationExpressionSyntaxWrapper.g.cs index 3fa9c21476..5fe6a3e14f 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitObjectCreationExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitObjectCreationExpressionSyntaxWrapper.g.cs @@ -89,5 +89,20 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + public ImplicitObjectCreationExpressionSyntaxWrapper WithNewKeyword(SyntaxToken newKeyword) + { + return new ImplicitObjectCreationExpressionSyntaxWrapper(WithNewKeywordAccessor(this.SyntaxNode, newKeyword)); + } + + public ImplicitObjectCreationExpressionSyntaxWrapper WithArgumentList(ArgumentListSyntax argumentList) + { + return new ImplicitObjectCreationExpressionSyntaxWrapper(WithArgumentListAccessor(this.SyntaxNode, argumentList)); + } + + public ImplicitObjectCreationExpressionSyntaxWrapper WithInitializer(InitializerExpressionSyntax initializer) + { + return new ImplicitObjectCreationExpressionSyntaxWrapper(WithInitializerAccessor(this.SyntaxNode, initializer)); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.g.cs index 9ce8b41bab..d9f1a213a6 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.g.cs @@ -97,5 +97,25 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + public ImplicitStackAllocArrayCreationExpressionSyntaxWrapper WithStackAllocKeyword(SyntaxToken stackAllocKeyword) + { + return new ImplicitStackAllocArrayCreationExpressionSyntaxWrapper(WithStackAllocKeywordAccessor(this.SyntaxNode, stackAllocKeyword)); + } + + public ImplicitStackAllocArrayCreationExpressionSyntaxWrapper WithOpenBracketToken(SyntaxToken openBracketToken) + { + return new ImplicitStackAllocArrayCreationExpressionSyntaxWrapper(WithOpenBracketTokenAccessor(this.SyntaxNode, openBracketToken)); + } + + public ImplicitStackAllocArrayCreationExpressionSyntaxWrapper WithCloseBracketToken(SyntaxToken closeBracketToken) + { + return new ImplicitStackAllocArrayCreationExpressionSyntaxWrapper(WithCloseBracketTokenAccessor(this.SyntaxNode, closeBracketToken)); + } + + public ImplicitStackAllocArrayCreationExpressionSyntaxWrapper WithInitializer(InitializerExpressionSyntax initializer) + { + return new ImplicitStackAllocArrayCreationExpressionSyntaxWrapper(WithInitializerAccessor(this.SyntaxNode, initializer)); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/IsPatternExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/IsPatternExpressionSyntaxWrapper.g.cs index fa4bf1b1fd..b5a770d8de 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/IsPatternExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/IsPatternExpressionSyntaxWrapper.g.cs @@ -85,5 +85,20 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + public IsPatternExpressionSyntaxWrapper WithExpression(ExpressionSyntax expression) + { + return new IsPatternExpressionSyntaxWrapper(WithExpressionAccessor(this.SyntaxNode, expression)); + } + + public IsPatternExpressionSyntaxWrapper WithIsKeyword(SyntaxToken isKeyword) + { + return new IsPatternExpressionSyntaxWrapper(WithIsKeywordAccessor(this.SyntaxNode, isKeyword)); + } + + public IsPatternExpressionSyntaxWrapper WithPattern(PatternSyntaxWrapper pattern) + { + return new IsPatternExpressionSyntaxWrapper(WithPatternAccessor(this.SyntaxNode, pattern)); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/LocalFunctionStatementSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/LocalFunctionStatementSyntaxWrapper.g.cs index 7941b6925b..29458dbb54 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/LocalFunctionStatementSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/LocalFunctionStatementSyntaxWrapper.g.cs @@ -167,5 +167,55 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + public LocalFunctionStatementSyntaxWrapper WithAttributeLists(SyntaxList attributeLists) + { + return new LocalFunctionStatementSyntaxWrapper(WithAttributeListsAccessor(this.SyntaxNode, attributeLists)); + } + + public LocalFunctionStatementSyntaxWrapper WithModifiers(SyntaxTokenList modifiers) + { + return new LocalFunctionStatementSyntaxWrapper(WithModifiersAccessor(this.SyntaxNode, modifiers)); + } + + public LocalFunctionStatementSyntaxWrapper WithReturnType(TypeSyntax returnType) + { + return new LocalFunctionStatementSyntaxWrapper(WithReturnTypeAccessor(this.SyntaxNode, returnType)); + } + + public LocalFunctionStatementSyntaxWrapper WithIdentifier(SyntaxToken identifier) + { + return new LocalFunctionStatementSyntaxWrapper(WithIdentifierAccessor(this.SyntaxNode, identifier)); + } + + public LocalFunctionStatementSyntaxWrapper WithTypeParameterList(TypeParameterListSyntax typeParameterList) + { + return new LocalFunctionStatementSyntaxWrapper(WithTypeParameterListAccessor(this.SyntaxNode, typeParameterList)); + } + + public LocalFunctionStatementSyntaxWrapper WithParameterList(ParameterListSyntax parameterList) + { + return new LocalFunctionStatementSyntaxWrapper(WithParameterListAccessor(this.SyntaxNode, parameterList)); + } + + public LocalFunctionStatementSyntaxWrapper WithConstraintClauses(SyntaxList constraintClauses) + { + return new LocalFunctionStatementSyntaxWrapper(WithConstraintClausesAccessor(this.SyntaxNode, constraintClauses)); + } + + public LocalFunctionStatementSyntaxWrapper WithBody(BlockSyntax body) + { + return new LocalFunctionStatementSyntaxWrapper(WithBodyAccessor(this.SyntaxNode, body)); + } + + public LocalFunctionStatementSyntaxWrapper WithExpressionBody(ArrowExpressionClauseSyntax expressionBody) + { + return new LocalFunctionStatementSyntaxWrapper(WithExpressionBodyAccessor(this.SyntaxNode, expressionBody)); + } + + public LocalFunctionStatementSyntaxWrapper WithSemicolonToken(SyntaxToken semicolonToken) + { + return new LocalFunctionStatementSyntaxWrapper(WithSemicolonTokenAccessor(this.SyntaxNode, semicolonToken)); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/NullableDirectiveTriviaSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/NullableDirectiveTriviaSyntaxWrapper.g.cs index 4cab39a1ec..a458688f54 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/NullableDirectiveTriviaSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/NullableDirectiveTriviaSyntaxWrapper.g.cs @@ -115,5 +115,35 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + public NullableDirectiveTriviaSyntaxWrapper WithHashToken(SyntaxToken hashToken) + { + return new NullableDirectiveTriviaSyntaxWrapper(WithHashTokenAccessor(this.SyntaxNode, hashToken)); + } + + public NullableDirectiveTriviaSyntaxWrapper WithNullableKeyword(SyntaxToken nullableKeyword) + { + return new NullableDirectiveTriviaSyntaxWrapper(WithNullableKeywordAccessor(this.SyntaxNode, nullableKeyword)); + } + + public NullableDirectiveTriviaSyntaxWrapper WithSettingToken(SyntaxToken settingToken) + { + return new NullableDirectiveTriviaSyntaxWrapper(WithSettingTokenAccessor(this.SyntaxNode, settingToken)); + } + + public NullableDirectiveTriviaSyntaxWrapper WithTargetToken(SyntaxToken targetToken) + { + return new NullableDirectiveTriviaSyntaxWrapper(WithTargetTokenAccessor(this.SyntaxNode, targetToken)); + } + + public NullableDirectiveTriviaSyntaxWrapper WithEndOfDirectiveToken(SyntaxToken endOfDirectiveToken) + { + return new NullableDirectiveTriviaSyntaxWrapper(WithEndOfDirectiveTokenAccessor(this.SyntaxNode, endOfDirectiveToken)); + } + + public NullableDirectiveTriviaSyntaxWrapper WithIsActive(bool isActive) + { + return new NullableDirectiveTriviaSyntaxWrapper(WithIsActiveAccessor(this.SyntaxNode, isActive)); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedPatternSyntaxWrapper.g.cs index 0493c0f731..bb365ccfde 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedPatternSyntaxWrapper.g.cs @@ -105,5 +105,20 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + public ParenthesizedPatternSyntaxWrapper WithOpenParenToken(SyntaxToken openParenToken) + { + return new ParenthesizedPatternSyntaxWrapper(WithOpenParenTokenAccessor(this.SyntaxNode, openParenToken)); + } + + public ParenthesizedPatternSyntaxWrapper WithPattern(PatternSyntaxWrapper pattern) + { + return new ParenthesizedPatternSyntaxWrapper(WithPatternAccessor(this.SyntaxNode, pattern)); + } + + public ParenthesizedPatternSyntaxWrapper WithCloseParenToken(SyntaxToken closeParenToken) + { + return new ParenthesizedPatternSyntaxWrapper(WithCloseParenTokenAccessor(this.SyntaxNode, closeParenToken)); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedVariableDesignationSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedVariableDesignationSyntaxWrapper.g.cs index bbee3c4f9e..31d8a930db 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedVariableDesignationSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedVariableDesignationSyntaxWrapper.g.cs @@ -95,5 +95,20 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + public ParenthesizedVariableDesignationSyntaxWrapper WithOpenParenToken(SyntaxToken openParenToken) + { + return new ParenthesizedVariableDesignationSyntaxWrapper(WithOpenParenTokenAccessor(this.SyntaxNode, openParenToken)); + } + + public ParenthesizedVariableDesignationSyntaxWrapper WithVariables(SeparatedSyntaxListWrapper variables) + { + return new ParenthesizedVariableDesignationSyntaxWrapper(WithVariablesAccessor(this.SyntaxNode, variables)); + } + + public ParenthesizedVariableDesignationSyntaxWrapper WithCloseParenToken(SyntaxToken closeParenToken) + { + return new ParenthesizedVariableDesignationSyntaxWrapper(WithCloseParenTokenAccessor(this.SyntaxNode, closeParenToken)); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PositionalPatternClauseSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PositionalPatternClauseSyntaxWrapper.g.cs index 04ccba1950..686bd9117b 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PositionalPatternClauseSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PositionalPatternClauseSyntaxWrapper.g.cs @@ -85,5 +85,20 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + public PositionalPatternClauseSyntaxWrapper WithOpenParenToken(SyntaxToken openParenToken) + { + return new PositionalPatternClauseSyntaxWrapper(WithOpenParenTokenAccessor(this.SyntaxNode, openParenToken)); + } + + public PositionalPatternClauseSyntaxWrapper WithSubpatterns(SeparatedSyntaxListWrapper subpatterns) + { + return new PositionalPatternClauseSyntaxWrapper(WithSubpatternsAccessor(this.SyntaxNode, subpatterns)); + } + + public PositionalPatternClauseSyntaxWrapper WithCloseParenToken(SyntaxToken closeParenToken) + { + return new PositionalPatternClauseSyntaxWrapper(WithCloseParenTokenAccessor(this.SyntaxNode, closeParenToken)); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PrimaryConstructorBaseTypeSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PrimaryConstructorBaseTypeSyntaxWrapper.g.cs index 9107b26b16..b1053e9b53 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PrimaryConstructorBaseTypeSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PrimaryConstructorBaseTypeSyntaxWrapper.g.cs @@ -71,5 +71,15 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + public PrimaryConstructorBaseTypeSyntaxWrapper WithType(TypeSyntax type) + { + return new PrimaryConstructorBaseTypeSyntaxWrapper(WithTypeAccessor(this.SyntaxNode, type)); + } + + public PrimaryConstructorBaseTypeSyntaxWrapper WithArgumentList(ArgumentListSyntax argumentList) + { + return new PrimaryConstructorBaseTypeSyntaxWrapper(WithArgumentListAccessor(this.SyntaxNode, argumentList)); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PropertyPatternClauseSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PropertyPatternClauseSyntaxWrapper.g.cs index cb104a92f9..9a2f79db68 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PropertyPatternClauseSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PropertyPatternClauseSyntaxWrapper.g.cs @@ -85,5 +85,20 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + public PropertyPatternClauseSyntaxWrapper WithOpenBraceToken(SyntaxToken openBraceToken) + { + return new PropertyPatternClauseSyntaxWrapper(WithOpenBraceTokenAccessor(this.SyntaxNode, openBraceToken)); + } + + public PropertyPatternClauseSyntaxWrapper WithSubpatterns(SeparatedSyntaxListWrapper subpatterns) + { + return new PropertyPatternClauseSyntaxWrapper(WithSubpatternsAccessor(this.SyntaxNode, subpatterns)); + } + + public PropertyPatternClauseSyntaxWrapper WithCloseBraceToken(SyntaxToken closeBraceToken) + { + return new PropertyPatternClauseSyntaxWrapper(WithCloseBraceTokenAccessor(this.SyntaxNode, closeBraceToken)); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RangeExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RangeExpressionSyntaxWrapper.g.cs index cdda148587..166fd4ed81 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RangeExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RangeExpressionSyntaxWrapper.g.cs @@ -85,5 +85,20 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + public RangeExpressionSyntaxWrapper WithLeftOperand(ExpressionSyntax leftOperand) + { + return new RangeExpressionSyntaxWrapper(WithLeftOperandAccessor(this.SyntaxNode, leftOperand)); + } + + public RangeExpressionSyntaxWrapper WithOperatorToken(SyntaxToken operatorToken) + { + return new RangeExpressionSyntaxWrapper(WithOperatorTokenAccessor(this.SyntaxNode, operatorToken)); + } + + public RangeExpressionSyntaxWrapper WithRightOperand(ExpressionSyntax rightOperand) + { + return new RangeExpressionSyntaxWrapper(WithRightOperandAccessor(this.SyntaxNode, rightOperand)); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecordDeclarationSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecordDeclarationSyntaxWrapper.g.cs index 30c934a185..887fc09777 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecordDeclarationSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecordDeclarationSyntaxWrapper.g.cs @@ -171,5 +171,65 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + public RecordDeclarationSyntaxWrapper WithAttributeLists(SyntaxList attributeLists) + { + return new RecordDeclarationSyntaxWrapper(WithAttributeListsAccessor(this.SyntaxNode, attributeLists)); + } + + public RecordDeclarationSyntaxWrapper WithModifiers(SyntaxTokenList modifiers) + { + return new RecordDeclarationSyntaxWrapper(WithModifiersAccessor(this.SyntaxNode, modifiers)); + } + + public RecordDeclarationSyntaxWrapper WithKeyword(SyntaxToken keyword) + { + return new RecordDeclarationSyntaxWrapper(WithKeywordAccessor(this.SyntaxNode, keyword)); + } + + public RecordDeclarationSyntaxWrapper WithIdentifier(SyntaxToken identifier) + { + return new RecordDeclarationSyntaxWrapper(WithIdentifierAccessor(this.SyntaxNode, identifier)); + } + + public RecordDeclarationSyntaxWrapper WithTypeParameterList(TypeParameterListSyntax typeParameterList) + { + return new RecordDeclarationSyntaxWrapper(WithTypeParameterListAccessor(this.SyntaxNode, typeParameterList)); + } + + public RecordDeclarationSyntaxWrapper WithParameterList(ParameterListSyntax parameterList) + { + return new RecordDeclarationSyntaxWrapper(WithParameterListAccessor(this.SyntaxNode, parameterList)); + } + + public RecordDeclarationSyntaxWrapper WithBaseList(BaseListSyntax baseList) + { + return new RecordDeclarationSyntaxWrapper(WithBaseListAccessor(this.SyntaxNode, baseList)); + } + + public RecordDeclarationSyntaxWrapper WithConstraintClauses(SyntaxList constraintClauses) + { + return new RecordDeclarationSyntaxWrapper(WithConstraintClausesAccessor(this.SyntaxNode, constraintClauses)); + } + + public RecordDeclarationSyntaxWrapper WithOpenBraceToken(SyntaxToken openBraceToken) + { + return new RecordDeclarationSyntaxWrapper(WithOpenBraceTokenAccessor(this.SyntaxNode, openBraceToken)); + } + + public RecordDeclarationSyntaxWrapper WithMembers(SyntaxList members) + { + return new RecordDeclarationSyntaxWrapper(WithMembersAccessor(this.SyntaxNode, members)); + } + + public RecordDeclarationSyntaxWrapper WithCloseBraceToken(SyntaxToken closeBraceToken) + { + return new RecordDeclarationSyntaxWrapper(WithCloseBraceTokenAccessor(this.SyntaxNode, closeBraceToken)); + } + + public RecordDeclarationSyntaxWrapper WithSemicolonToken(SyntaxToken semicolonToken) + { + return new RecordDeclarationSyntaxWrapper(WithSemicolonTokenAccessor(this.SyntaxNode, semicolonToken)); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecursivePatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecursivePatternSyntaxWrapper.g.cs index fc6e22697b..babe64fd6c 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecursivePatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecursivePatternSyntaxWrapper.g.cs @@ -117,5 +117,25 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + public RecursivePatternSyntaxWrapper WithType(TypeSyntax type) + { + return new RecursivePatternSyntaxWrapper(WithTypeAccessor(this.SyntaxNode, type)); + } + + public RecursivePatternSyntaxWrapper WithPositionalPatternClause(PositionalPatternClauseSyntaxWrapper positionalPatternClause) + { + return new RecursivePatternSyntaxWrapper(WithPositionalPatternClauseAccessor(this.SyntaxNode, positionalPatternClause)); + } + + public RecursivePatternSyntaxWrapper WithPropertyPatternClause(PropertyPatternClauseSyntaxWrapper propertyPatternClause) + { + return new RecursivePatternSyntaxWrapper(WithPropertyPatternClauseAccessor(this.SyntaxNode, propertyPatternClause)); + } + + public RecursivePatternSyntaxWrapper WithDesignation(VariableDesignationSyntaxWrapper designation) + { + return new RecursivePatternSyntaxWrapper(WithDesignationAccessor(this.SyntaxNode, designation)); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefExpressionSyntaxWrapper.g.cs index e2ec2b9a45..77c4d3e321 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefExpressionSyntaxWrapper.g.cs @@ -73,5 +73,15 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + public RefExpressionSyntaxWrapper WithRefKeyword(SyntaxToken refKeyword) + { + return new RefExpressionSyntaxWrapper(WithRefKeywordAccessor(this.SyntaxNode, refKeyword)); + } + + public RefExpressionSyntaxWrapper WithExpression(ExpressionSyntax expression) + { + return new RefExpressionSyntaxWrapper(WithExpressionAccessor(this.SyntaxNode, expression)); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefTypeSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefTypeSyntaxWrapper.g.cs index 37aa77e94c..769f658fc8 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefTypeSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefTypeSyntaxWrapper.g.cs @@ -85,5 +85,20 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + public RefTypeSyntaxWrapper WithRefKeyword(SyntaxToken refKeyword) + { + return new RefTypeSyntaxWrapper(WithRefKeywordAccessor(this.SyntaxNode, refKeyword)); + } + + public RefTypeSyntaxWrapper WithReadOnlyKeyword(SyntaxToken readOnlyKeyword) + { + return new RefTypeSyntaxWrapper(WithReadOnlyKeywordAccessor(this.SyntaxNode, readOnlyKeyword)); + } + + public RefTypeSyntaxWrapper WithType(TypeSyntax type) + { + return new RefTypeSyntaxWrapper(WithTypeAccessor(this.SyntaxNode, type)); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RelationalPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RelationalPatternSyntaxWrapper.g.cs index dbbc75d44b..7d71552e97 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RelationalPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RelationalPatternSyntaxWrapper.g.cs @@ -93,5 +93,15 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + public RelationalPatternSyntaxWrapper WithOperatorToken(SyntaxToken operatorToken) + { + return new RelationalPatternSyntaxWrapper(WithOperatorTokenAccessor(this.SyntaxNode, operatorToken)); + } + + public RelationalPatternSyntaxWrapper WithExpression(ExpressionSyntax expression) + { + return new RelationalPatternSyntaxWrapper(WithExpressionAccessor(this.SyntaxNode, expression)); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SingleVariableDesignationSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SingleVariableDesignationSyntaxWrapper.g.cs index 4651d3bee9..c27b2f3a07 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SingleVariableDesignationSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SingleVariableDesignationSyntaxWrapper.g.cs @@ -71,5 +71,10 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + public SingleVariableDesignationSyntaxWrapper WithIdentifier(SyntaxToken identifier) + { + return new SingleVariableDesignationSyntaxWrapper(WithIdentifierAccessor(this.SyntaxNode, identifier)); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SubpatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SubpatternSyntaxWrapper.g.cs index cd0921aa9a..e8db37b078 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SubpatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SubpatternSyntaxWrapper.g.cs @@ -73,5 +73,15 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + public SubpatternSyntaxWrapper WithNameColon(NameColonSyntax nameColon) + { + return new SubpatternSyntaxWrapper(WithNameColonAccessor(this.SyntaxNode, nameColon)); + } + + public SubpatternSyntaxWrapper WithPattern(PatternSyntaxWrapper pattern) + { + return new SubpatternSyntaxWrapper(WithPatternAccessor(this.SyntaxNode, pattern)); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionArmSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionArmSyntaxWrapper.g.cs index b53c53ca58..1f7bf7d380 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionArmSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionArmSyntaxWrapper.g.cs @@ -97,5 +97,25 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + public SwitchExpressionArmSyntaxWrapper WithPattern(PatternSyntaxWrapper pattern) + { + return new SwitchExpressionArmSyntaxWrapper(WithPatternAccessor(this.SyntaxNode, pattern)); + } + + public SwitchExpressionArmSyntaxWrapper WithWhenClause(WhenClauseSyntaxWrapper whenClause) + { + return new SwitchExpressionArmSyntaxWrapper(WithWhenClauseAccessor(this.SyntaxNode, whenClause)); + } + + public SwitchExpressionArmSyntaxWrapper WithEqualsGreaterThanToken(SyntaxToken equalsGreaterThanToken) + { + return new SwitchExpressionArmSyntaxWrapper(WithEqualsGreaterThanTokenAccessor(this.SyntaxNode, equalsGreaterThanToken)); + } + + public SwitchExpressionArmSyntaxWrapper WithExpression(ExpressionSyntax expression) + { + return new SwitchExpressionArmSyntaxWrapper(WithExpressionAccessor(this.SyntaxNode, expression)); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionSyntaxWrapper.g.cs index 36e0d9eb3e..f35bfa6f81 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionSyntaxWrapper.g.cs @@ -109,5 +109,30 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + public SwitchExpressionSyntaxWrapper WithGoverningExpression(ExpressionSyntax governingExpression) + { + return new SwitchExpressionSyntaxWrapper(WithGoverningExpressionAccessor(this.SyntaxNode, governingExpression)); + } + + public SwitchExpressionSyntaxWrapper WithSwitchKeyword(SyntaxToken switchKeyword) + { + return new SwitchExpressionSyntaxWrapper(WithSwitchKeywordAccessor(this.SyntaxNode, switchKeyword)); + } + + public SwitchExpressionSyntaxWrapper WithOpenBraceToken(SyntaxToken openBraceToken) + { + return new SwitchExpressionSyntaxWrapper(WithOpenBraceTokenAccessor(this.SyntaxNode, openBraceToken)); + } + + public SwitchExpressionSyntaxWrapper WithArms(SeparatedSyntaxListWrapper arms) + { + return new SwitchExpressionSyntaxWrapper(WithArmsAccessor(this.SyntaxNode, arms)); + } + + public SwitchExpressionSyntaxWrapper WithCloseBraceToken(SyntaxToken closeBraceToken) + { + return new SwitchExpressionSyntaxWrapper(WithCloseBraceTokenAccessor(this.SyntaxNode, closeBraceToken)); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ThrowExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ThrowExpressionSyntaxWrapper.g.cs index 38c8441fe2..c52368cc74 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ThrowExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ThrowExpressionSyntaxWrapper.g.cs @@ -73,5 +73,15 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + public ThrowExpressionSyntaxWrapper WithThrowKeyword(SyntaxToken throwKeyword) + { + return new ThrowExpressionSyntaxWrapper(WithThrowKeywordAccessor(this.SyntaxNode, throwKeyword)); + } + + public ThrowExpressionSyntaxWrapper WithExpression(ExpressionSyntax expression) + { + return new ThrowExpressionSyntaxWrapper(WithExpressionAccessor(this.SyntaxNode, expression)); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleElementSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleElementSyntaxWrapper.g.cs index 5eda947247..35b045a7c2 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleElementSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleElementSyntaxWrapper.g.cs @@ -73,5 +73,15 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + public TupleElementSyntaxWrapper WithType(TypeSyntax type) + { + return new TupleElementSyntaxWrapper(WithTypeAccessor(this.SyntaxNode, type)); + } + + public TupleElementSyntaxWrapper WithIdentifier(SyntaxToken identifier) + { + return new TupleElementSyntaxWrapper(WithIdentifierAccessor(this.SyntaxNode, identifier)); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleExpressionSyntaxWrapper.g.cs index bf1d1e0b3d..8c91cc021a 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleExpressionSyntaxWrapper.g.cs @@ -85,5 +85,20 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + public TupleExpressionSyntaxWrapper WithOpenParenToken(SyntaxToken openParenToken) + { + return new TupleExpressionSyntaxWrapper(WithOpenParenTokenAccessor(this.SyntaxNode, openParenToken)); + } + + public TupleExpressionSyntaxWrapper WithArguments(SeparatedSyntaxList arguments) + { + return new TupleExpressionSyntaxWrapper(WithArgumentsAccessor(this.SyntaxNode, arguments)); + } + + public TupleExpressionSyntaxWrapper WithCloseParenToken(SyntaxToken closeParenToken) + { + return new TupleExpressionSyntaxWrapper(WithCloseParenTokenAccessor(this.SyntaxNode, closeParenToken)); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleTypeSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleTypeSyntaxWrapper.g.cs index 61ab682270..4ce129d8cb 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleTypeSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleTypeSyntaxWrapper.g.cs @@ -85,5 +85,20 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + public TupleTypeSyntaxWrapper WithOpenParenToken(SyntaxToken openParenToken) + { + return new TupleTypeSyntaxWrapper(WithOpenParenTokenAccessor(this.SyntaxNode, openParenToken)); + } + + public TupleTypeSyntaxWrapper WithElements(SeparatedSyntaxListWrapper elements) + { + return new TupleTypeSyntaxWrapper(WithElementsAccessor(this.SyntaxNode, elements)); + } + + public TupleTypeSyntaxWrapper WithCloseParenToken(SyntaxToken closeParenToken) + { + return new TupleTypeSyntaxWrapper(WithCloseParenTokenAccessor(this.SyntaxNode, closeParenToken)); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TypePatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TypePatternSyntaxWrapper.g.cs index 8589b46986..b4066b6da5 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TypePatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TypePatternSyntaxWrapper.g.cs @@ -81,5 +81,10 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + public TypePatternSyntaxWrapper WithType(TypeSyntax type) + { + return new TypePatternSyntaxWrapper(WithTypeAccessor(this.SyntaxNode, type)); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/UnaryPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/UnaryPatternSyntaxWrapper.g.cs index 3300d7302c..b20510764d 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/UnaryPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/UnaryPatternSyntaxWrapper.g.cs @@ -93,5 +93,15 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + public UnaryPatternSyntaxWrapper WithOperatorToken(SyntaxToken operatorToken) + { + return new UnaryPatternSyntaxWrapper(WithOperatorTokenAccessor(this.SyntaxNode, operatorToken)); + } + + public UnaryPatternSyntaxWrapper WithPattern(PatternSyntaxWrapper pattern) + { + return new UnaryPatternSyntaxWrapper(WithPatternAccessor(this.SyntaxNode, pattern)); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VarPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VarPatternSyntaxWrapper.g.cs index abe451cfe8..3aa513637d 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VarPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VarPatternSyntaxWrapper.g.cs @@ -93,5 +93,15 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + public VarPatternSyntaxWrapper WithVarKeyword(SyntaxToken varKeyword) + { + return new VarPatternSyntaxWrapper(WithVarKeywordAccessor(this.SyntaxNode, varKeyword)); + } + + public VarPatternSyntaxWrapper WithDesignation(VariableDesignationSyntaxWrapper designation) + { + return new VarPatternSyntaxWrapper(WithDesignationAccessor(this.SyntaxNode, designation)); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WhenClauseSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WhenClauseSyntaxWrapper.g.cs index f36ba30407..75d595a1a5 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WhenClauseSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WhenClauseSyntaxWrapper.g.cs @@ -73,5 +73,15 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + public WhenClauseSyntaxWrapper WithWhenKeyword(SyntaxToken whenKeyword) + { + return new WhenClauseSyntaxWrapper(WithWhenKeywordAccessor(this.SyntaxNode, whenKeyword)); + } + + public WhenClauseSyntaxWrapper WithCondition(ExpressionSyntax condition) + { + return new WhenClauseSyntaxWrapper(WithConditionAccessor(this.SyntaxNode, condition)); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WithExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WithExpressionSyntaxWrapper.g.cs index 96b3e5aafb..0474cca4d6 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WithExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WithExpressionSyntaxWrapper.g.cs @@ -85,5 +85,20 @@ public static bool IsInstance(SyntaxNode node) { return node != null && LightupHelpers.CanWrapNode(node, WrappedType); } + + public WithExpressionSyntaxWrapper WithExpression(ExpressionSyntax expression) + { + return new WithExpressionSyntaxWrapper(WithExpressionAccessor(this.SyntaxNode, expression)); + } + + public WithExpressionSyntaxWrapper WithWithKeyword(SyntaxToken withKeyword) + { + return new WithExpressionSyntaxWrapper(WithWithKeywordAccessor(this.SyntaxNode, withKeyword)); + } + + public WithExpressionSyntaxWrapper WithInitializer(InitializerExpressionSyntax initializer) + { + return new WithExpressionSyntaxWrapper(WithInitializerAccessor(this.SyntaxNode, initializer)); + } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CasePatternSwitchLabelSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CasePatternSwitchLabelSyntaxWrapper.cs deleted file mode 100644 index e4ec03282b..0000000000 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CasePatternSwitchLabelSyntaxWrapper.cs +++ /dev/null @@ -1,31 +0,0 @@ -// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. -// Licensed under the MIT License. See LICENSE in the project root for license information. - -namespace StyleCop.Analyzers.Lightup -{ - using Microsoft.CodeAnalysis; - using Microsoft.CodeAnalysis.CSharp.Syntax; - - internal partial struct CasePatternSwitchLabelSyntaxWrapper : ISyntaxWrapper - { - public CasePatternSwitchLabelSyntaxWrapper WithKeyword(SyntaxToken keyword) - { - return new CasePatternSwitchLabelSyntaxWrapper(WithKeywordAccessor(this.SyntaxNode, keyword)); - } - - public CasePatternSwitchLabelSyntaxWrapper WithColonToken(SyntaxToken colonToken) - { - return new CasePatternSwitchLabelSyntaxWrapper(WithColonTokenAccessor(this.SyntaxNode, colonToken)); - } - - public CasePatternSwitchLabelSyntaxWrapper WithPattern(PatternSyntaxWrapper pattern) - { - return new CasePatternSwitchLabelSyntaxWrapper(WithPatternAccessor(this.SyntaxNode, pattern)); - } - - public CasePatternSwitchLabelSyntaxWrapper WithWhenClause(WhenClauseSyntaxWrapper whenClause) - { - return new CasePatternSwitchLabelSyntaxWrapper(WithWhenClauseAccessor(this.SyntaxNode, whenClause)); - } - } -} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CommonForEachStatementSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CommonForEachStatementSyntaxWrapper.cs index 53bc9a83c1..b025d8637d 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CommonForEachStatementSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/CommonForEachStatementSyntaxWrapper.cs @@ -3,7 +3,6 @@ namespace StyleCop.Analyzers.Lightup { - using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp.Syntax; internal partial struct CommonForEachStatementSyntaxWrapper : ISyntaxWrapper @@ -14,40 +13,5 @@ public static implicit operator CommonForEachStatementSyntaxWrapper(ForEachState { return new CommonForEachStatementSyntaxWrapper(node); } - - public CommonForEachStatementSyntaxWrapper WithAwaitKeyword(SyntaxToken awaitKeyword) - { - return new CommonForEachStatementSyntaxWrapper(WithAwaitKeywordAccessor(this.SyntaxNode, awaitKeyword)); - } - - public CommonForEachStatementSyntaxWrapper WithForEachKeyword(SyntaxToken forEachKeyword) - { - return new CommonForEachStatementSyntaxWrapper(WithForEachKeywordAccessor(this.SyntaxNode, forEachKeyword)); - } - - public CommonForEachStatementSyntaxWrapper WithOpenParenToken(SyntaxToken openParenToken) - { - return new CommonForEachStatementSyntaxWrapper(WithOpenParenTokenAccessor(this.SyntaxNode, openParenToken)); - } - - public CommonForEachStatementSyntaxWrapper WithInKeyword(SyntaxToken inKeyword) - { - return new CommonForEachStatementSyntaxWrapper(WithInKeywordAccessor(this.SyntaxNode, inKeyword)); - } - - public CommonForEachStatementSyntaxWrapper WithExpression(ExpressionSyntax expression) - { - return new CommonForEachStatementSyntaxWrapper(WithExpressionAccessor(this.SyntaxNode, expression)); - } - - public CommonForEachStatementSyntaxWrapper WithCloseParenToken(SyntaxToken closeParenToken) - { - return new CommonForEachStatementSyntaxWrapper(WithCloseParenTokenAccessor(this.SyntaxNode, closeParenToken)); - } - - public CommonForEachStatementSyntaxWrapper WithStatement(StatementSyntax statement) - { - return new CommonForEachStatementSyntaxWrapper(WithStatementAccessor(this.SyntaxNode, statement)); - } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ConstantPatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ConstantPatternSyntaxWrapper.cs deleted file mode 100644 index 6281af6bc0..0000000000 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ConstantPatternSyntaxWrapper.cs +++ /dev/null @@ -1,16 +0,0 @@ -// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. -// Licensed under the MIT License. See LICENSE in the project root for license information. - -namespace StyleCop.Analyzers.Lightup -{ - using Microsoft.CodeAnalysis.CSharp; - using Microsoft.CodeAnalysis.CSharp.Syntax; - - internal partial struct ConstantPatternSyntaxWrapper : ISyntaxWrapper - { - public ConstantPatternSyntaxWrapper WithExpression(ExpressionSyntax expression) - { - return new ConstantPatternSyntaxWrapper(WithExpressionAccessor(this.SyntaxNode, expression)); - } - } -} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationExpressionSyntaxWrapper.cs deleted file mode 100644 index 0e83240be2..0000000000 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationExpressionSyntaxWrapper.cs +++ /dev/null @@ -1,20 +0,0 @@ -// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. -// Licensed under the MIT License. See LICENSE in the project root for license information. - -namespace StyleCop.Analyzers.Lightup -{ - using Microsoft.CodeAnalysis.CSharp.Syntax; - - internal partial struct DeclarationExpressionSyntaxWrapper : ISyntaxWrapper - { - public DeclarationExpressionSyntaxWrapper WithType(TypeSyntax type) - { - return new DeclarationExpressionSyntaxWrapper(WithTypeAccessor(this.SyntaxNode, type)); - } - - public DeclarationExpressionSyntaxWrapper WithDesignation(VariableDesignationSyntaxWrapper designation) - { - return new DeclarationExpressionSyntaxWrapper(WithDesignationAccessor(this.SyntaxNode, designation.SyntaxNode)); - } - } -} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationPatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationPatternSyntaxWrapper.cs deleted file mode 100644 index 168ce09de3..0000000000 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DeclarationPatternSyntaxWrapper.cs +++ /dev/null @@ -1,21 +0,0 @@ -// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. -// Licensed under the MIT License. See LICENSE in the project root for license information. - -namespace StyleCop.Analyzers.Lightup -{ - using Microsoft.CodeAnalysis.CSharp; - using Microsoft.CodeAnalysis.CSharp.Syntax; - - internal partial struct DeclarationPatternSyntaxWrapper : ISyntaxWrapper - { - public DeclarationPatternSyntaxWrapper WithType(TypeSyntax type) - { - return new DeclarationPatternSyntaxWrapper(WithTypeAccessor(this.SyntaxNode, type)); - } - - public DeclarationPatternSyntaxWrapper WithDesignation(VariableDesignationSyntaxWrapper designation) - { - return new DeclarationPatternSyntaxWrapper(WithDesignationAccessor(this.SyntaxNode, designation.SyntaxNode)); - } - } -} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardDesignationSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardDesignationSyntaxWrapper.cs deleted file mode 100644 index 410cfc67e7..0000000000 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardDesignationSyntaxWrapper.cs +++ /dev/null @@ -1,16 +0,0 @@ -// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. -// Licensed under the MIT License. See LICENSE in the project root for license information. - -namespace StyleCop.Analyzers.Lightup -{ - using Microsoft.CodeAnalysis; - using Microsoft.CodeAnalysis.CSharp; - - internal partial struct DiscardDesignationSyntaxWrapper : ISyntaxWrapper - { - public DiscardDesignationSyntaxWrapper WithUnderscoreToken(SyntaxToken identifier) - { - return new DiscardDesignationSyntaxWrapper(WithUnderscoreTokenAccessor(this.SyntaxNode, identifier)); - } - } -} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardPatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardPatternSyntaxWrapper.cs deleted file mode 100644 index bc026e9d3e..0000000000 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/DiscardPatternSyntaxWrapper.cs +++ /dev/null @@ -1,16 +0,0 @@ -// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. -// Licensed under the MIT License. See LICENSE in the project root for license information. - -namespace StyleCop.Analyzers.Lightup -{ - using Microsoft.CodeAnalysis; - using Microsoft.CodeAnalysis.CSharp; - - internal partial struct DiscardPatternSyntaxWrapper : ISyntaxWrapper - { - public DiscardPatternSyntaxWrapper WithUnderscoreToken(SyntaxToken identifier) - { - return new DiscardPatternSyntaxWrapper(WithUnderscoreTokenAccessor(this.SyntaxNode, identifier)); - } - } -} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ForEachVariableStatementSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ForEachVariableStatementSyntaxWrapper.cs deleted file mode 100644 index b3f29bd32f..0000000000 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ForEachVariableStatementSyntaxWrapper.cs +++ /dev/null @@ -1,51 +0,0 @@ -// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. -// Licensed under the MIT License. See LICENSE in the project root for license information. - -namespace StyleCop.Analyzers.Lightup -{ - using Microsoft.CodeAnalysis; - using Microsoft.CodeAnalysis.CSharp.Syntax; - - internal partial struct ForEachVariableStatementSyntaxWrapper : ISyntaxWrapper - { - public ForEachVariableStatementSyntaxWrapper WithAwaitKeyword(SyntaxToken awaitKeyword) - { - return new ForEachVariableStatementSyntaxWrapper(WithAwaitKeywordAccessor(this.SyntaxNode, awaitKeyword)); - } - - public ForEachVariableStatementSyntaxWrapper WithForEachKeyword(SyntaxToken forEachKeyword) - { - return new ForEachVariableStatementSyntaxWrapper(WithForEachKeywordAccessor(this.SyntaxNode, forEachKeyword)); - } - - public ForEachVariableStatementSyntaxWrapper WithOpenParenToken(SyntaxToken openParenToken) - { - return new ForEachVariableStatementSyntaxWrapper(WithOpenParenTokenAccessor(this.SyntaxNode, openParenToken)); - } - - public ForEachVariableStatementSyntaxWrapper WithVariable(ExpressionSyntax variable) - { - return new ForEachVariableStatementSyntaxWrapper(WithVariableAccessor(this.SyntaxNode, variable)); - } - - public ForEachVariableStatementSyntaxWrapper WithInKeyword(SyntaxToken inKeyword) - { - return new ForEachVariableStatementSyntaxWrapper(WithInKeywordAccessor(this.SyntaxNode, inKeyword)); - } - - public ForEachVariableStatementSyntaxWrapper WithExpression(ExpressionSyntax expression) - { - return new ForEachVariableStatementSyntaxWrapper(WithExpressionAccessor(this.SyntaxNode, expression)); - } - - public ForEachVariableStatementSyntaxWrapper WithCloseParenToken(SyntaxToken closeParenToken) - { - return new ForEachVariableStatementSyntaxWrapper(WithCloseParenTokenAccessor(this.SyntaxNode, closeParenToken)); - } - - public ForEachVariableStatementSyntaxWrapper WithStatement(StatementSyntax statement) - { - return new ForEachVariableStatementSyntaxWrapper(WithStatementAccessor(this.SyntaxNode, statement)); - } - } -} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.cs index f9b3fe5cda..b220383f43 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.cs @@ -3,31 +3,10 @@ namespace StyleCop.Analyzers.Lightup { - using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp.Syntax; internal partial struct ImplicitStackAllocArrayCreationExpressionSyntaxWrapper : ISyntaxWrapper { - public ImplicitStackAllocArrayCreationExpressionSyntaxWrapper WithStackAllocKeyword(SyntaxToken stackAllocKeyword) - { - return new ImplicitStackAllocArrayCreationExpressionSyntaxWrapper(WithStackAllocKeywordAccessor(this.SyntaxNode, stackAllocKeyword)); - } - - public ImplicitStackAllocArrayCreationExpressionSyntaxWrapper WithOpenBracketToken(SyntaxToken openBracketToken) - { - return new ImplicitStackAllocArrayCreationExpressionSyntaxWrapper(WithOpenBracketTokenAccessor(this.SyntaxNode, openBracketToken)); - } - - public ImplicitStackAllocArrayCreationExpressionSyntaxWrapper WithCloseBracketToken(SyntaxToken closeBracketToken) - { - return new ImplicitStackAllocArrayCreationExpressionSyntaxWrapper(WithCloseBracketTokenAccessor(this.SyntaxNode, closeBracketToken)); - } - - public ImplicitStackAllocArrayCreationExpressionSyntaxWrapper WithInitializer(InitializerExpressionSyntax initializer) - { - return new ImplicitStackAllocArrayCreationExpressionSyntaxWrapper(WithInitializerAccessor(this.SyntaxNode, initializer)); - } - public ImplicitStackAllocArrayCreationExpressionSyntaxWrapper AddInitializerExpressions(params ExpressionSyntax[] items) { return new ImplicitStackAllocArrayCreationExpressionSyntaxWrapper(this.WithInitializer(this.Initializer.AddExpressions(items))); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/IsPatternExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/IsPatternExpressionSyntaxWrapper.cs deleted file mode 100644 index f45acbc966..0000000000 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/IsPatternExpressionSyntaxWrapper.cs +++ /dev/null @@ -1,26 +0,0 @@ -// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. -// Licensed under the MIT License. See LICENSE in the project root for license information. - -namespace StyleCop.Analyzers.Lightup -{ - using Microsoft.CodeAnalysis; - using Microsoft.CodeAnalysis.CSharp.Syntax; - - internal partial struct IsPatternExpressionSyntaxWrapper : ISyntaxWrapper - { - public IsPatternExpressionSyntaxWrapper WithExpression(ExpressionSyntax expression) - { - return new IsPatternExpressionSyntaxWrapper(WithExpressionAccessor(this.SyntaxNode, expression)); - } - - public IsPatternExpressionSyntaxWrapper WithIsKeyword(SyntaxToken isKeyword) - { - return new IsPatternExpressionSyntaxWrapper(WithIsKeywordAccessor(this.SyntaxNode, isKeyword)); - } - - public IsPatternExpressionSyntaxWrapper WithPattern(PatternSyntaxWrapper pattern) - { - return new IsPatternExpressionSyntaxWrapper(WithPatternAccessor(this.SyntaxNode, pattern.SyntaxNode)); - } - } -} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/LocalFunctionStatementSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/LocalFunctionStatementSyntaxWrapper.cs index f83f718506..4fdaf3f7b8 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/LocalFunctionStatementSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/LocalFunctionStatementSyntaxWrapper.cs @@ -9,51 +9,6 @@ namespace StyleCop.Analyzers.Lightup internal partial struct LocalFunctionStatementSyntaxWrapper : ISyntaxWrapper { - public LocalFunctionStatementSyntaxWrapper WithModifiers(SyntaxTokenList modifiers) - { - return new LocalFunctionStatementSyntaxWrapper(WithModifiersAccessor(this.SyntaxNode, modifiers)); - } - - public LocalFunctionStatementSyntaxWrapper WithReturnType(TypeSyntax returnType) - { - return new LocalFunctionStatementSyntaxWrapper(WithReturnTypeAccessor(this.SyntaxNode, returnType)); - } - - public LocalFunctionStatementSyntaxWrapper WithIdentifier(SyntaxToken identifier) - { - return new LocalFunctionStatementSyntaxWrapper(WithIdentifierAccessor(this.SyntaxNode, identifier)); - } - - public LocalFunctionStatementSyntaxWrapper WithTypeParameterList(TypeParameterListSyntax typeParameterList) - { - return new LocalFunctionStatementSyntaxWrapper(WithTypeParameterListAccessor(this.SyntaxNode, typeParameterList)); - } - - public LocalFunctionStatementSyntaxWrapper WithParameterList(ParameterListSyntax parameterList) - { - return new LocalFunctionStatementSyntaxWrapper(WithParameterListAccessor(this.SyntaxNode, parameterList)); - } - - public LocalFunctionStatementSyntaxWrapper WithConstraintClauses(SyntaxList constraintClauses) - { - return new LocalFunctionStatementSyntaxWrapper(WithConstraintClausesAccessor(this.SyntaxNode, constraintClauses)); - } - - public LocalFunctionStatementSyntaxWrapper WithBody(BlockSyntax body) - { - return new LocalFunctionStatementSyntaxWrapper(WithBodyAccessor(this.SyntaxNode, body)); - } - - public LocalFunctionStatementSyntaxWrapper WithExpressionBody(ArrowExpressionClauseSyntax expressionBody) - { - return new LocalFunctionStatementSyntaxWrapper(WithExpressionBodyAccessor(this.SyntaxNode, expressionBody)); - } - - public LocalFunctionStatementSyntaxWrapper WithSemicolonToken(SyntaxToken semicolonToken) - { - return new LocalFunctionStatementSyntaxWrapper(WithSemicolonTokenAccessor(this.SyntaxNode, semicolonToken)); - } - public LocalFunctionStatementSyntaxWrapper AddModifiers(params SyntaxToken[] items) { return this.WithModifiers(this.Modifiers.AddRange(items)); diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ParenthesizedVariableDesignationSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ParenthesizedVariableDesignationSyntaxWrapper.cs index e56d256037..ee3f285d5c 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ParenthesizedVariableDesignationSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ParenthesizedVariableDesignationSyntaxWrapper.cs @@ -3,7 +3,6 @@ namespace StyleCop.Analyzers.Lightup { - using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; internal partial struct ParenthesizedVariableDesignationSyntaxWrapper : ISyntaxWrapper @@ -12,20 +11,5 @@ public ParenthesizedVariableDesignationSyntaxWrapper AddVariables(params Variabl { return new ParenthesizedVariableDesignationSyntaxWrapper(this.WithVariables(this.Variables.AddRange(items))); } - - public ParenthesizedVariableDesignationSyntaxWrapper WithOpenParenToken(SyntaxToken identifier) - { - return new ParenthesizedVariableDesignationSyntaxWrapper(WithOpenParenTokenAccessor(this.SyntaxNode, identifier)); - } - - public ParenthesizedVariableDesignationSyntaxWrapper WithVariables(SeparatedSyntaxListWrapper variables) - { - return new ParenthesizedVariableDesignationSyntaxWrapper(WithVariablesAccessor(this.SyntaxNode, variables)); - } - - public ParenthesizedVariableDesignationSyntaxWrapper WithCloseParenToken(SyntaxToken identifier) - { - return new ParenthesizedVariableDesignationSyntaxWrapper(WithCloseParenTokenAccessor(this.SyntaxNode, identifier)); - } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PositionalPatternClauseSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PositionalPatternClauseSyntaxWrapper.cs index de67ecc094..5c26c17942 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PositionalPatternClauseSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PositionalPatternClauseSyntaxWrapper.cs @@ -3,7 +3,6 @@ namespace StyleCop.Analyzers.Lightup { - using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; internal partial struct PositionalPatternClauseSyntaxWrapper : ISyntaxWrapper @@ -12,20 +11,5 @@ public PositionalPatternClauseSyntaxWrapper AddSubpatterns(params SubpatternSynt { return new PositionalPatternClauseSyntaxWrapper(this.WithSubpatterns(this.Subpatterns.AddRange(items))); } - - public PositionalPatternClauseSyntaxWrapper WithOpenParenToken(SyntaxToken openParenToken) - { - return new PositionalPatternClauseSyntaxWrapper(WithOpenParenTokenAccessor(this.SyntaxNode, openParenToken)); - } - - public PositionalPatternClauseSyntaxWrapper WithSubpatterns(SeparatedSyntaxListWrapper subpatterns) - { - return new PositionalPatternClauseSyntaxWrapper(WithSubpatternsAccessor(this.SyntaxNode, subpatterns)); - } - - public PositionalPatternClauseSyntaxWrapper WithCloseParenToken(SyntaxToken closeParenToken) - { - return new PositionalPatternClauseSyntaxWrapper(WithCloseParenTokenAccessor(this.SyntaxNode, closeParenToken)); - } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PropertyPatternClauseSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PropertyPatternClauseSyntaxWrapper.cs index d4e78a49ae..76e450d284 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PropertyPatternClauseSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/PropertyPatternClauseSyntaxWrapper.cs @@ -3,7 +3,6 @@ namespace StyleCop.Analyzers.Lightup { - using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp; internal partial struct PropertyPatternClauseSyntaxWrapper : ISyntaxWrapper @@ -12,20 +11,5 @@ public PropertyPatternClauseSyntaxWrapper AddSubpatterns(params SubpatternSyntax { return new PropertyPatternClauseSyntaxWrapper(this.WithSubpatterns(this.Subpatterns.AddRange(items))); } - - public PropertyPatternClauseSyntaxWrapper WithOpenBraceToken(SyntaxToken openBraceToken) - { - return new PropertyPatternClauseSyntaxWrapper(WithOpenBraceTokenAccessor(this.SyntaxNode, openBraceToken)); - } - - public PropertyPatternClauseSyntaxWrapper WithSubpatterns(SeparatedSyntaxListWrapper subpatterns) - { - return new PropertyPatternClauseSyntaxWrapper(WithSubpatternsAccessor(this.SyntaxNode, subpatterns)); - } - - public PropertyPatternClauseSyntaxWrapper WithCloseBraceToken(SyntaxToken closeBraceToken) - { - return new PropertyPatternClauseSyntaxWrapper(WithCloseBraceTokenAccessor(this.SyntaxNode, closeBraceToken)); - } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RangeExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RangeExpressionSyntaxWrapper.cs deleted file mode 100644 index 57845a92e5..0000000000 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RangeExpressionSyntaxWrapper.cs +++ /dev/null @@ -1,26 +0,0 @@ -// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. -// Licensed under the MIT License. See LICENSE in the project root for license information. - -namespace StyleCop.Analyzers.Lightup -{ - using Microsoft.CodeAnalysis; - using Microsoft.CodeAnalysis.CSharp.Syntax; - - internal partial struct RangeExpressionSyntaxWrapper : ISyntaxWrapper - { - public RangeExpressionSyntaxWrapper WithLeftOperand(ExpressionSyntax leftOperand) - { - return new RangeExpressionSyntaxWrapper(WithLeftOperandAccessor(this.SyntaxNode, leftOperand)); - } - - public RangeExpressionSyntaxWrapper WithOperatorToken(SyntaxToken operatorToken) - { - return new RangeExpressionSyntaxWrapper(WithOperatorTokenAccessor(this.SyntaxNode, operatorToken)); - } - - public RangeExpressionSyntaxWrapper WithRightOperand(ExpressionSyntax rightOperand) - { - return new RangeExpressionSyntaxWrapper(WithRightOperandAccessor(this.SyntaxNode, rightOperand)); - } - } -} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RecursivePatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RecursivePatternSyntaxWrapper.cs index cbc1f04046..6937995123 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RecursivePatternSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RecursivePatternSyntaxWrapper.cs @@ -4,7 +4,6 @@ namespace StyleCop.Analyzers.Lightup { using Microsoft.CodeAnalysis.CSharp; - using Microsoft.CodeAnalysis.CSharp.Syntax; internal partial struct RecursivePatternSyntaxWrapper : ISyntaxWrapper { @@ -29,25 +28,5 @@ public RecursivePatternSyntaxWrapper AddPropertyPatternClauseSubpatterns(params return this.WithPropertyPatternClause(propertyPatternClause.WithSubpatterns(propertyPatternClause.Subpatterns.AddRange(items))); } - - public RecursivePatternSyntaxWrapper WithType(TypeSyntax type) - { - return new RecursivePatternSyntaxWrapper(WithTypeAccessor(this.SyntaxNode, type)); - } - - public RecursivePatternSyntaxWrapper WithPositionalPatternClause(PositionalPatternClauseSyntaxWrapper positionalPatternClause) - { - return new RecursivePatternSyntaxWrapper(WithPositionalPatternClauseAccessor(this.SyntaxNode, positionalPatternClause)); - } - - public RecursivePatternSyntaxWrapper WithPropertyPatternClause(PropertyPatternClauseSyntaxWrapper propertyPatternClause) - { - return new RecursivePatternSyntaxWrapper(WithPropertyPatternClauseAccessor(this.SyntaxNode, propertyPatternClause)); - } - - public RecursivePatternSyntaxWrapper WithDesignation(VariableDesignationSyntaxWrapper designation) - { - return new RecursivePatternSyntaxWrapper(WithDesignationAccessor(this.SyntaxNode, designation)); - } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefExpressionSyntaxWrapper.cs deleted file mode 100644 index bbc7d65a1d..0000000000 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefExpressionSyntaxWrapper.cs +++ /dev/null @@ -1,21 +0,0 @@ -// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. -// Licensed under the MIT License. See LICENSE in the project root for license information. - -namespace StyleCop.Analyzers.Lightup -{ - using Microsoft.CodeAnalysis; - using Microsoft.CodeAnalysis.CSharp.Syntax; - - internal partial struct RefExpressionSyntaxWrapper : ISyntaxWrapper - { - public RefExpressionSyntaxWrapper WithRefKeyword(SyntaxToken refKeyword) - { - return new RefExpressionSyntaxWrapper(WithRefKeywordAccessor(this.SyntaxNode, refKeyword)); - } - - public RefExpressionSyntaxWrapper WithExpression(ExpressionSyntax expression) - { - return new RefExpressionSyntaxWrapper(WithExpressionAccessor(this.SyntaxNode, expression)); - } - } -} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefTypeSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefTypeSyntaxWrapper.cs deleted file mode 100644 index 690b22f73e..0000000000 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/RefTypeSyntaxWrapper.cs +++ /dev/null @@ -1,26 +0,0 @@ -// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. -// Licensed under the MIT License. See LICENSE in the project root for license information. - -namespace StyleCop.Analyzers.Lightup -{ - using Microsoft.CodeAnalysis; - using Microsoft.CodeAnalysis.CSharp.Syntax; - - internal partial struct RefTypeSyntaxWrapper : ISyntaxWrapper - { - public RefTypeSyntaxWrapper WithRefKeyword(SyntaxToken refKeyword) - { - return new RefTypeSyntaxWrapper(WithRefKeywordAccessor(this.SyntaxNode, refKeyword)); - } - - public RefTypeSyntaxWrapper WithReadOnlyKeyword(SyntaxToken readOnlyKeyword) - { - return new RefTypeSyntaxWrapper(WithReadOnlyKeywordAccessor(this.SyntaxNode, readOnlyKeyword)); - } - - public RefTypeSyntaxWrapper WithType(TypeSyntax type) - { - return new RefTypeSyntaxWrapper(WithTypeAccessor(this.SyntaxNode, type)); - } - } -} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SingleVariableDesignationSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SingleVariableDesignationSyntaxWrapper.cs deleted file mode 100644 index 11b6ae5296..0000000000 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SingleVariableDesignationSyntaxWrapper.cs +++ /dev/null @@ -1,16 +0,0 @@ -// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. -// Licensed under the MIT License. See LICENSE in the project root for license information. - -namespace StyleCop.Analyzers.Lightup -{ - using Microsoft.CodeAnalysis; - using Microsoft.CodeAnalysis.CSharp; - - internal partial struct SingleVariableDesignationSyntaxWrapper : ISyntaxWrapper - { - public SingleVariableDesignationSyntaxWrapper WithIdentifier(SyntaxToken identifier) - { - return new SingleVariableDesignationSyntaxWrapper(WithIdentifierAccessor(this.SyntaxNode, identifier)); - } - } -} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SubpatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SubpatternSyntaxWrapper.cs deleted file mode 100644 index 268dcaaa0a..0000000000 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SubpatternSyntaxWrapper.cs +++ /dev/null @@ -1,21 +0,0 @@ -// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. -// Licensed under the MIT License. See LICENSE in the project root for license information. - -namespace StyleCop.Analyzers.Lightup -{ - using Microsoft.CodeAnalysis.CSharp; - using Microsoft.CodeAnalysis.CSharp.Syntax; - - internal partial struct SubpatternSyntaxWrapper : ISyntaxWrapper - { - public SubpatternSyntaxWrapper WithNameColon(NameColonSyntax nameColon) - { - return new SubpatternSyntaxWrapper(WithNameColonAccessor(this.SyntaxNode, nameColon)); - } - - public SubpatternSyntaxWrapper WithPattern(PatternSyntaxWrapper pattern) - { - return new SubpatternSyntaxWrapper(WithPatternAccessor(this.SyntaxNode, pattern)); - } - } -} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionArmSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionArmSyntaxWrapper.cs deleted file mode 100644 index 1872e2bc81..0000000000 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionArmSyntaxWrapper.cs +++ /dev/null @@ -1,32 +0,0 @@ -// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. -// Licensed under the MIT License. See LICENSE in the project root for license information. - -namespace StyleCop.Analyzers.Lightup -{ - using Microsoft.CodeAnalysis; - using Microsoft.CodeAnalysis.CSharp; - using Microsoft.CodeAnalysis.CSharp.Syntax; - - internal partial struct SwitchExpressionArmSyntaxWrapper : ISyntaxWrapper - { - public SwitchExpressionArmSyntaxWrapper WithPattern(PatternSyntaxWrapper pattern) - { - return new SwitchExpressionArmSyntaxWrapper(WithPatternAccessor(this.SyntaxNode, pattern.SyntaxNode)); - } - - public SwitchExpressionArmSyntaxWrapper WithWhenClause(WhenClauseSyntaxWrapper whenClause) - { - return new SwitchExpressionArmSyntaxWrapper(WithWhenClauseAccessor(this.SyntaxNode, whenClause)); - } - - public SwitchExpressionArmSyntaxWrapper WithExpression(ExpressionSyntax expression) - { - return new SwitchExpressionArmSyntaxWrapper(WithExpressionAccessor(this.SyntaxNode, expression)); - } - - public SwitchExpressionArmSyntaxWrapper WithEqualsGreaterThanToken(SyntaxToken equalsGreaterThanToken) - { - return new SwitchExpressionArmSyntaxWrapper(WithEqualsGreaterThanTokenAccessor(this.SyntaxNode, equalsGreaterThanToken)); - } - } -} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionSyntaxWrapper.cs index 8065658628..984eccef53 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/SwitchExpressionSyntaxWrapper.cs @@ -3,7 +3,6 @@ namespace StyleCop.Analyzers.Lightup { - using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp.Syntax; internal partial struct SwitchExpressionSyntaxWrapper : ISyntaxWrapper @@ -12,30 +11,5 @@ public SwitchExpressionSyntaxWrapper AddArms(params SwitchExpressionArmSyntaxWra { return new SwitchExpressionSyntaxWrapper(this.WithArms(this.Arms.AddRange(arms))); } - - public SwitchExpressionSyntaxWrapper WithArms(SeparatedSyntaxListWrapper arms) - { - return new SwitchExpressionSyntaxWrapper(WithArmsAccessor(this.SyntaxNode, arms)); - } - - public SwitchExpressionSyntaxWrapper WithCloseBraceToken(SyntaxToken closeBraceToken) - { - return new SwitchExpressionSyntaxWrapper(WithCloseBraceTokenAccessor(this.SyntaxNode, closeBraceToken)); - } - - public SwitchExpressionSyntaxWrapper WithGoverningExpression(ExpressionSyntax expression) - { - return new SwitchExpressionSyntaxWrapper(WithGoverningExpressionAccessor(this.SyntaxNode, expression)); - } - - public SwitchExpressionSyntaxWrapper WithOpenBraceToken(SyntaxToken openBraceToken) - { - return new SwitchExpressionSyntaxWrapper(WithOpenBraceTokenAccessor(this.SyntaxNode, openBraceToken)); - } - - public SwitchExpressionSyntaxWrapper WithSwitchKeyword(SyntaxToken switchKeyword) - { - return new SwitchExpressionSyntaxWrapper(WithSwitchKeywordAccessor(this.SyntaxNode, switchKeyword)); - } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ThrowExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ThrowExpressionSyntaxWrapper.cs deleted file mode 100644 index 5d75ff842f..0000000000 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/ThrowExpressionSyntaxWrapper.cs +++ /dev/null @@ -1,21 +0,0 @@ -// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. -// Licensed under the MIT License. See LICENSE in the project root for license information. - -namespace StyleCop.Analyzers.Lightup -{ - using Microsoft.CodeAnalysis; - using Microsoft.CodeAnalysis.CSharp.Syntax; - - internal partial struct ThrowExpressionSyntaxWrapper : ISyntaxWrapper - { - public ThrowExpressionSyntaxWrapper WithThrowKeyword(SyntaxToken throwKeyword) - { - return new ThrowExpressionSyntaxWrapper(WithThrowKeywordAccessor(this.SyntaxNode, throwKeyword)); - } - - public ThrowExpressionSyntaxWrapper WithExpression(ExpressionSyntax expression) - { - return new ThrowExpressionSyntaxWrapper(WithExpressionAccessor(this.SyntaxNode, expression)); - } - } -} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleElementSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleElementSyntaxWrapper.cs deleted file mode 100644 index 19a4069e3d..0000000000 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleElementSyntaxWrapper.cs +++ /dev/null @@ -1,22 +0,0 @@ -// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. -// Licensed under the MIT License. See LICENSE in the project root for license information. - -namespace StyleCop.Analyzers.Lightup -{ - using Microsoft.CodeAnalysis; - using Microsoft.CodeAnalysis.CSharp; - using Microsoft.CodeAnalysis.CSharp.Syntax; - - internal partial struct TupleElementSyntaxWrapper : ISyntaxWrapper - { - public TupleElementSyntaxWrapper WithIdentifier(SyntaxToken identifier) - { - return new TupleElementSyntaxWrapper(WithIdentifierAccessor(this.SyntaxNode, identifier)); - } - - public TupleElementSyntaxWrapper WithType(TypeSyntax type) - { - return new TupleElementSyntaxWrapper(WithTypeAccessor(this.SyntaxNode, type)); - } - } -} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleExpressionSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleExpressionSyntaxWrapper.cs index 6a1a47a8b8..43a961d94b 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleExpressionSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleExpressionSyntaxWrapper.cs @@ -3,7 +3,6 @@ namespace StyleCop.Analyzers.Lightup { - using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp.Syntax; internal partial struct TupleExpressionSyntaxWrapper : ISyntaxWrapper @@ -12,20 +11,5 @@ public TupleExpressionSyntaxWrapper AddArguments(params ArgumentSyntax[] items) { return new TupleExpressionSyntaxWrapper(this.WithArguments(this.Arguments.AddRange(items))); } - - public TupleExpressionSyntaxWrapper WithOpenParenToken(SyntaxToken openParenToken) - { - return new TupleExpressionSyntaxWrapper(WithOpenParenTokenAccessor(this.SyntaxNode, openParenToken)); - } - - public TupleExpressionSyntaxWrapper WithArguments(SeparatedSyntaxList arguments) - { - return new TupleExpressionSyntaxWrapper(WithArgumentsAccessor(this.SyntaxNode, arguments)); - } - - public TupleExpressionSyntaxWrapper WithCloseParenToken(SyntaxToken closeParenToken) - { - return new TupleExpressionSyntaxWrapper(WithCloseParenTokenAccessor(this.SyntaxNode, closeParenToken)); - } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleTypeSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleTypeSyntaxWrapper.cs index 3a409ed0f4..bef163710c 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleTypeSyntaxWrapper.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/TupleTypeSyntaxWrapper.cs @@ -3,7 +3,6 @@ namespace StyleCop.Analyzers.Lightup { - using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp.Syntax; internal partial struct TupleTypeSyntaxWrapper : ISyntaxWrapper @@ -12,20 +11,5 @@ public TupleTypeSyntaxWrapper AddElements(params TupleElementSyntaxWrapper[] ite { return new TupleTypeSyntaxWrapper(this.WithElements(this.Elements.AddRange(items))); } - - public TupleTypeSyntaxWrapper WithOpenParenToken(SyntaxToken openParenToken) - { - return new TupleTypeSyntaxWrapper(WithOpenParenTokenAccessor(this.SyntaxNode, openParenToken)); - } - - public TupleTypeSyntaxWrapper WithElements(SeparatedSyntaxListWrapper elements) - { - return new TupleTypeSyntaxWrapper(WithElementsAccessor(this.SyntaxNode, elements)); - } - - public TupleTypeSyntaxWrapper WithCloseParenToken(SyntaxToken closeParenToken) - { - return new TupleTypeSyntaxWrapper(WithCloseParenTokenAccessor(this.SyntaxNode, closeParenToken)); - } } } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VarPatternSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VarPatternSyntaxWrapper.cs deleted file mode 100644 index ba3aaf1ea5..0000000000 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/VarPatternSyntaxWrapper.cs +++ /dev/null @@ -1,21 +0,0 @@ -// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. -// Licensed under the MIT License. See LICENSE in the project root for license information. - -namespace StyleCop.Analyzers.Lightup -{ - using Microsoft.CodeAnalysis; - using Microsoft.CodeAnalysis.CSharp; - - internal partial struct VarPatternSyntaxWrapper : ISyntaxWrapper - { - public VarPatternSyntaxWrapper WithVarKeyword(SyntaxToken varKeyword) - { - return new VarPatternSyntaxWrapper(WithVarKeywordAccessor(this.SyntaxNode, varKeyword)); - } - - public VarPatternSyntaxWrapper WithDesignation(VariableDesignationSyntaxWrapper designation) - { - return new VarPatternSyntaxWrapper(WithDesignationAccessor(this.SyntaxNode, designation)); - } - } -} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/WhenClauseSyntaxWrapper.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/WhenClauseSyntaxWrapper.cs deleted file mode 100644 index 3573b5e80a..0000000000 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/WhenClauseSyntaxWrapper.cs +++ /dev/null @@ -1,22 +0,0 @@ -// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. -// Licensed under the MIT License. See LICENSE in the project root for license information. - -namespace StyleCop.Analyzers.Lightup -{ - using Microsoft.CodeAnalysis; - using Microsoft.CodeAnalysis.CSharp; - using Microsoft.CodeAnalysis.CSharp.Syntax; - - internal partial struct WhenClauseSyntaxWrapper : ISyntaxWrapper - { - public WhenClauseSyntaxWrapper WithWhenKeyword(SyntaxToken whenKeyword) - { - return new WhenClauseSyntaxWrapper(WithWhenKeywordAccessor(this.SyntaxNode, whenKeyword)); - } - - public WhenClauseSyntaxWrapper WithCondition(ExpressionSyntax condition) - { - return new WhenClauseSyntaxWrapper(WithConditionAccessor(this.SyntaxNode, condition)); - } - } -} From 510d9492468b008e21f6127778e387157584000d Mon Sep 17 00:00:00 2001 From: Sam Harwell Date: Tue, 1 Dec 2020 18:14:09 -0800 Subject: [PATCH 17/18] Generate documentation comment for GetWrappedType --- .../OperationLightupGenerator.cs | 24 +++++++++++++++++++ .../SyntaxLightupGenerator.cs | 24 +++++++++++++++++++ .../OperationWrapperHelper.g.cs | 5 ++++ .../SyntaxWrapperHelper.g.cs | 5 ++++ 4 files changed, 58 insertions(+) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/OperationLightupGenerator.cs b/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/OperationLightupGenerator.cs index 7d9c9be26e..2c287c21fb 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/OperationLightupGenerator.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/OperationLightupGenerator.cs @@ -684,6 +684,11 @@ private void GenerateOperationWrapperHelper(in GeneratorExecutionContext context body: SyntaxFactory.Block(staticCtorStatements), expressionBody: null); + // /// + // /// Gets the type that is wrapped by the given wrapper. + // /// + // /// Type of the wrapper for which the wrapped type should be retrieved. + // /// The wrapped type, or null if there is no info. // internal static Type GetWrappedType(Type wrapperType) // { // if (WrappedTypes.TryGetValue(wrapperType, out Type wrappedType)) @@ -730,6 +735,25 @@ private void GenerateOperationWrapperHelper(in GeneratorExecutionContext context SyntaxFactory.ReturnStatement(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression))), expressionBody: null); + getWrappedType = getWrappedType.WithLeadingTrivia(SyntaxFactory.TriviaList( + SyntaxFactory.Trivia(SyntaxFactory.DocumentationComment( + SyntaxFactory.XmlText(" "), + SyntaxFactory.XmlSummaryElement( + SyntaxFactory.XmlNewLine(Environment.NewLine), + SyntaxFactory.XmlText(" Gets the type that is wrapped by the given wrapper."), + SyntaxFactory.XmlNewLine(Environment.NewLine), + SyntaxFactory.XmlText(" ")), + SyntaxFactory.XmlNewLine(Environment.NewLine), + SyntaxFactory.XmlText(" "), + SyntaxFactory.XmlParamElement( + "wrapperType", + SyntaxFactory.XmlText("Type of the wrapper for which the wrapped type should be retrieved.")), + SyntaxFactory.XmlNewLine(Environment.NewLine), + SyntaxFactory.XmlText(" "), + SyntaxFactory.XmlReturnsElement( + SyntaxFactory.XmlText("The wrapped type, or null if there is no info.")), + SyntaxFactory.XmlNewLine(Environment.NewLine).WithoutTrailingTrivia())))); + var wrapperHelperClass = SyntaxFactory.ClassDeclaration( attributeLists: default, modifiers: SyntaxTokenList.Create(SyntaxFactory.Token(SyntaxKind.InternalKeyword)).Add(SyntaxFactory.Token(SyntaxKind.StaticKeyword)), diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs b/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs index a03fc7d926..e372c0fa49 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs @@ -935,6 +935,11 @@ private void GenerateSyntaxWrapperHelper(in GeneratorExecutionContext context, I body: SyntaxFactory.Block(staticCtorStatements), expressionBody: null); + // /// + // /// Gets the type that is wrapped by the given wrapper. + // /// + // /// Type of the wrapper for which the wrapped type should be retrieved. + // /// The wrapped type, or null if there is no info. // internal static Type GetWrappedType(Type wrapperType) // { // if (WrappedTypes.TryGetValue(wrapperType, out Type wrappedType)) @@ -981,6 +986,25 @@ private void GenerateSyntaxWrapperHelper(in GeneratorExecutionContext context, I SyntaxFactory.ReturnStatement(SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression))), expressionBody: null); + getWrappedType = getWrappedType.WithLeadingTrivia(SyntaxFactory.TriviaList( + SyntaxFactory.Trivia(SyntaxFactory.DocumentationComment( + SyntaxFactory.XmlText(" "), + SyntaxFactory.XmlSummaryElement( + SyntaxFactory.XmlNewLine(Environment.NewLine), + SyntaxFactory.XmlText(" Gets the type that is wrapped by the given wrapper."), + SyntaxFactory.XmlNewLine(Environment.NewLine), + SyntaxFactory.XmlText(" ")), + SyntaxFactory.XmlNewLine(Environment.NewLine), + SyntaxFactory.XmlText(" "), + SyntaxFactory.XmlParamElement( + "wrapperType", + SyntaxFactory.XmlText("Type of the wrapper for which the wrapped type should be retrieved.")), + SyntaxFactory.XmlNewLine(Environment.NewLine), + SyntaxFactory.XmlText(" "), + SyntaxFactory.XmlReturnsElement( + SyntaxFactory.XmlText("The wrapped type, or null if there is no info.")), + SyntaxFactory.XmlNewLine(Environment.NewLine).WithoutTrailingTrivia())))); + var wrapperHelperClass = SyntaxFactory.ClassDeclaration( attributeLists: default, modifiers: SyntaxTokenList.Create(SyntaxFactory.Token(SyntaxKind.InternalKeyword)).Add(SyntaxFactory.Token(SyntaxKind.StaticKeyword)), diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.OperationLightupGenerator/OperationWrapperHelper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.OperationLightupGenerator/OperationWrapperHelper.g.cs index 4427f80e76..371e9bf6f6 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.OperationLightupGenerator/OperationWrapperHelper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.OperationLightupGenerator/OperationWrapperHelper.g.cs @@ -140,6 +140,11 @@ static OperationWrapperHelper() WrappedTypes = builder.ToImmutable(); } + /// + /// Gets the type that is wrapped by the given wrapper. + /// + /// Type of the wrapper for which the wrapped type should be retrieved. + /// The wrapped type, or null if there is no info. internal static Type GetWrappedType(Type wrapperType) { if (WrappedTypes.TryGetValue(wrapperType, out Type wrappedType)) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SyntaxWrapperHelper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SyntaxWrapperHelper.g.cs index 2550fb7686..f6beee5dec 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SyntaxWrapperHelper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SyntaxWrapperHelper.g.cs @@ -70,6 +70,11 @@ static SyntaxWrapperHelper() WrappedTypes = builder.ToImmutable(); } + /// + /// Gets the type that is wrapped by the given wrapper. + /// + /// Type of the wrapper for which the wrapped type should be retrieved. + /// The wrapped type, or null if there is no info. internal static Type GetWrappedType(Type wrapperType) { if (WrappedTypes.TryGetValue(wrapperType, out Type wrappedType)) From 237ea8e8256234f077679090623087f3c66a7764 Mon Sep 17 00:00:00 2001 From: Sam Harwell Date: Tue, 1 Dec 2020 18:43:11 -0800 Subject: [PATCH 18/18] Generate blank lines to improve code style --- .../GeneratorSyntaxExtensions.cs | 19 +++++ .../SyntaxLightupGenerator.cs | 71 +++++++++++++++---- ...ObjectCreationExpressionSyntaxWrapper.g.cs | 4 ++ .../BaseParameterSyntaxWrapper.g.cs | 4 ++ .../BinaryPatternSyntaxWrapper.g.cs | 4 ++ .../CasePatternSwitchLabelSyntaxWrapper.g.cs | 4 ++ .../CommonForEachStatementSyntaxWrapper.g.cs | 4 ++ .../ConstantPatternSyntaxWrapper.g.cs | 4 ++ .../DeclarationExpressionSyntaxWrapper.g.cs | 4 ++ .../DeclarationPatternSyntaxWrapper.g.cs | 4 ++ .../DefaultConstraintSyntaxWrapper.g.cs | 4 ++ .../DiscardDesignationSyntaxWrapper.g.cs | 4 ++ .../DiscardPatternSyntaxWrapper.g.cs | 4 ++ .../ExpressionOrPatternSyntaxWrapper.g.cs | 3 + ...ForEachVariableStatementSyntaxWrapper.g.cs | 4 ++ ...PointerCallingConventionSyntaxWrapper.g.cs | 4 ++ ...tionPointerParameterListSyntaxWrapper.g.cs | 4 ++ ...FunctionPointerParameterSyntaxWrapper.g.cs | 3 + .../FunctionPointerTypeSyntaxWrapper.g.cs | 4 ++ ...gedCallingConventionListSyntaxWrapper.g.cs | 4 ++ ...managedCallingConventionSyntaxWrapper.g.cs | 4 ++ ...ObjectCreationExpressionSyntaxWrapper.g.cs | 3 + ...cArrayCreationExpressionSyntaxWrapper.g.cs | 4 ++ .../IsPatternExpressionSyntaxWrapper.g.cs | 4 ++ .../LocalFunctionStatementSyntaxWrapper.g.cs | 4 ++ .../NullableDirectiveTriviaSyntaxWrapper.g.cs | 4 ++ .../ParenthesizedPatternSyntaxWrapper.g.cs | 4 ++ ...sizedVariableDesignationSyntaxWrapper.g.cs | 4 ++ .../PatternSyntaxWrapper.g.cs | 3 + .../PositionalPatternClauseSyntaxWrapper.g.cs | 4 ++ ...imaryConstructorBaseTypeSyntaxWrapper.g.cs | 4 ++ .../PropertyPatternClauseSyntaxWrapper.g.cs | 4 ++ .../RangeExpressionSyntaxWrapper.g.cs | 4 ++ .../RecordDeclarationSyntaxWrapper.g.cs | 4 ++ .../RecursivePatternSyntaxWrapper.g.cs | 4 ++ .../RefExpressionSyntaxWrapper.g.cs | 4 ++ .../RefTypeSyntaxWrapper.g.cs | 4 ++ .../RelationalPatternSyntaxWrapper.g.cs | 4 ++ ...ingleVariableDesignationSyntaxWrapper.g.cs | 4 ++ .../SubpatternSyntaxWrapper.g.cs | 4 ++ .../SwitchExpressionArmSyntaxWrapper.g.cs | 4 ++ .../SwitchExpressionSyntaxWrapper.g.cs | 4 ++ .../SyntaxWrapperHelper.g.cs | 3 + .../ThrowExpressionSyntaxWrapper.g.cs | 4 ++ .../TupleElementSyntaxWrapper.g.cs | 4 ++ .../TupleExpressionSyntaxWrapper.g.cs | 4 ++ .../TupleTypeSyntaxWrapper.g.cs | 4 ++ .../TypePatternSyntaxWrapper.g.cs | 4 ++ .../UnaryPatternSyntaxWrapper.g.cs | 4 ++ .../VarPatternSyntaxWrapper.g.cs | 4 ++ .../VariableDesignationSyntaxWrapper.g.cs | 3 + .../WhenClauseSyntaxWrapper.g.cs | 4 ++ .../WithExpressionSyntaxWrapper.g.cs | 4 ++ 53 files changed, 274 insertions(+), 14 deletions(-) create mode 100644 StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/GeneratorSyntaxExtensions.cs diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/GeneratorSyntaxExtensions.cs b/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/GeneratorSyntaxExtensions.cs new file mode 100644 index 0000000000..ad25f4aa38 --- /dev/null +++ b/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/GeneratorSyntaxExtensions.cs @@ -0,0 +1,19 @@ +// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved. +// Licensed under the MIT License. See LICENSE in the project root for license information. + +namespace StyleCop.Analyzers.CodeGeneration +{ + using System; + using Microsoft.CodeAnalysis; + using Microsoft.CodeAnalysis.CSharp; + + internal static class GeneratorSyntaxExtensions + { + public static TSyntax WithLeadingBlankLine(this TSyntax syntax) + where TSyntax : SyntaxNode + { + return syntax.WithLeadingTrivia(SyntaxFactory.TriviaList( + SyntaxFactory.PreprocessingMessage(Environment.NewLine))); + } + } +} diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs b/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs index e372c0fa49..7308e921f7 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers.CodeGeneration/SyntaxLightupGenerator.cs @@ -85,6 +85,7 @@ private void GenerateSyntaxWrapper(in GeneratorExecutionContext context, SyntaxD type: SyntaxFactory.IdentifierName("Type"), variables: SyntaxFactory.SingletonSeparatedList(SyntaxFactory.VariableDeclarator("WrappedType"))))); + bool first = true; foreach (var field in nodeData.Fields) { if (field.IsSkipped) @@ -99,7 +100,7 @@ private void GenerateSyntaxWrapper(in GeneratorExecutionContext context, SyntaxD } // private static readonly Func FieldAccessor; - members = members.Add(SyntaxFactory.FieldDeclaration( + FieldDeclarationSyntax fieldAccessor = SyntaxFactory.FieldDeclaration( attributeLists: default, modifiers: SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PrivateKeyword), SyntaxFactory.Token(SyntaxKind.StaticKeyword), SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword)), declaration: SyntaxFactory.VariableDeclaration( @@ -111,7 +112,15 @@ private void GenerateSyntaxWrapper(in GeneratorExecutionContext context, SyntaxD SyntaxFactory.IdentifierName(concreteBase), SyntaxFactory.ParseTypeName(field.GetAccessorResultType(syntaxData)), }))), - variables: SyntaxFactory.SingletonSeparatedList(SyntaxFactory.VariableDeclarator(field.AccessorName))))); + variables: SyntaxFactory.SingletonSeparatedList(SyntaxFactory.VariableDeclarator(field.AccessorName)))); + + if (first) + { + fieldAccessor = fieldAccessor.WithLeadingBlankLine(); + first = false; + } + + members = members.Add(fieldAccessor); } foreach (var field in nodeData.Fields) @@ -144,7 +153,7 @@ private void GenerateSyntaxWrapper(in GeneratorExecutionContext context, SyntaxD modifiers: SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PrivateKeyword), SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword)), declaration: SyntaxFactory.VariableDeclaration( type: SyntaxFactory.IdentifierName(concreteBase), - variables: SyntaxFactory.SingletonSeparatedList(SyntaxFactory.VariableDeclarator("node"))))); + variables: SyntaxFactory.SingletonSeparatedList(SyntaxFactory.VariableDeclarator("node")))).WithLeadingBlankLine()); // WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(SyntaxWrapper)); var staticCtorStatements = SyntaxFactory.SingletonList( @@ -284,7 +293,7 @@ private void GenerateSyntaxWrapper(in GeneratorExecutionContext context, SyntaxD parameterList: SyntaxFactory.ParameterList(), initializer: null, body: SyntaxFactory.Block(staticCtorStatements), - expressionBody: null)); + expressionBody: null).WithLeadingBlankLine()); // private SyntaxNodeWrapper(SyntaxNode node) // { @@ -333,6 +342,7 @@ private void GenerateSyntaxWrapper(in GeneratorExecutionContext context, SyntaxD // return ...; // } // } + first = true; foreach (var field in nodeData.Fields) { if (field.IsSkipped) @@ -426,7 +436,7 @@ private void GenerateSyntaxWrapper(in GeneratorExecutionContext context, SyntaxD // return ...; // } // } - members = members.Add(SyntaxFactory.PropertyDeclaration( + PropertyDeclarationSyntax property = SyntaxFactory.PropertyDeclaration( attributeLists: default, modifiers: SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword)), type: propertyType, @@ -438,7 +448,15 @@ private void GenerateSyntaxWrapper(in GeneratorExecutionContext context, SyntaxD SyntaxFactory.ReturnStatement(returnExpression))))), expressionBody: null, initializer: null, - semicolonToken: default)); + semicolonToken: default); + + if (first) + { + property = property.WithLeadingBlankLine(); + first = false; + } + + members = members.Add(property); } for (var baseNode = syntaxData.TryGetNode(nodeData.BaseName); baseNode?.WrapperName is not null; baseNode = syntaxData.TryGetNode(baseNode.BaseName)) @@ -447,7 +465,7 @@ private void GenerateSyntaxWrapper(in GeneratorExecutionContext context, SyntaxD // { // return (SyntaxWrapper)node.SyntaxNode; // } - members = members.Add(SyntaxFactory.ConversionOperatorDeclaration( + ConversionOperatorDeclarationSyntax wrapperConversion = SyntaxFactory.ConversionOperatorDeclaration( attributeLists: default, modifiers: SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword), SyntaxFactory.Token(SyntaxKind.StaticKeyword)), implicitOrExplicitKeyword: SyntaxFactory.Token(SyntaxKind.ExplicitKeyword), @@ -467,7 +485,15 @@ private void GenerateSyntaxWrapper(in GeneratorExecutionContext context, SyntaxD expression: SyntaxFactory.IdentifierName("node"), name: SyntaxFactory.IdentifierName("SyntaxNode"))))), expressionBody: null, - semicolonToken: default)); + semicolonToken: default); + + if (first) + { + wrapperConversion = wrapperConversion.WithLeadingBlankLine(); + first = false; + } + + members = members.Add(wrapperConversion); } // public static explicit operator WhenClauseSyntaxWrapper(SyntaxNode node) @@ -484,7 +510,7 @@ private void GenerateSyntaxWrapper(in GeneratorExecutionContext context, SyntaxD // // return new WhenClauseSyntaxWrapper((CSharpSyntaxNode)node); // } - members = members.Add(SyntaxFactory.ConversionOperatorDeclaration( + var nodeConversion = SyntaxFactory.ConversionOperatorDeclaration( attributeLists: default, modifiers: SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword), SyntaxFactory.Token(SyntaxKind.StaticKeyword)), implicitOrExplicitKeyword: SyntaxFactory.Token(SyntaxKind.ExplicitKeyword), @@ -556,7 +582,15 @@ private void GenerateSyntaxWrapper(in GeneratorExecutionContext context, SyntaxD expression: SyntaxFactory.IdentifierName("node"))))), initializer: null))), expressionBody: null, - semicolonToken: default)); + semicolonToken: default); + + if (first) + { + nodeConversion = nodeConversion.WithLeadingBlankLine(); + first = false; + } + + members = members.Add(nodeConversion); for (var baseNode = syntaxData.TryGetNode(nodeData.BaseName); baseNode?.WrapperName is not null; baseNode = syntaxData.TryGetNode(baseNode.BaseName)) { @@ -827,6 +861,7 @@ private void GenerateSyntaxWrapperHelper(in GeneratorExecutionContext context, I SyntaxFactory.IdentifierName("Type"), }))))))))))); + bool first = true; foreach (var node in wrapperTypes.OrderBy(node => node.Name, StringComparer.OrdinalIgnoreCase)) { if (node.WrapperName is null) @@ -890,7 +925,7 @@ private void GenerateSyntaxWrapperHelper(in GeneratorExecutionContext context, I } // builder.Add(typeof(ConstantPatternSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(ConstantPatternSyntaxWrapper.WrappedTypeName)); - staticCtorStatements = staticCtorStatements.Add(SyntaxFactory.ExpressionStatement( + ExpressionStatementSyntax statement = SyntaxFactory.ExpressionStatement( SyntaxFactory.InvocationExpression( expression: SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, @@ -912,7 +947,15 @@ private void GenerateSyntaxWrapperHelper(in GeneratorExecutionContext context, I SyntaxKind.SimpleMemberAccessExpression, expression: SyntaxFactory.IdentifierName(node.WrapperName), name: SyntaxFactory.IdentifierName("WrappedTypeName"))))))), - }))))); + })))); + + if (first) + { + statement = statement.WithLeadingBlankLine(); + first = false; + } + + staticCtorStatements = staticCtorStatements.Add(statement); } // WrappedTypes = builder.ToImmutable(); @@ -924,7 +967,7 @@ private void GenerateSyntaxWrapperHelper(in GeneratorExecutionContext context, I SyntaxFactory.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, expression: SyntaxFactory.IdentifierName("builder"), - name: SyntaxFactory.IdentifierName("ToImmutable")))))); + name: SyntaxFactory.IdentifierName("ToImmutable"))))).WithLeadingBlankLine()); var staticCtor = SyntaxFactory.ConstructorDeclaration( attributeLists: default, @@ -933,7 +976,7 @@ private void GenerateSyntaxWrapperHelper(in GeneratorExecutionContext context, I parameterList: SyntaxFactory.ParameterList(), initializer: null, body: SyntaxFactory.Block(staticCtorStatements), - expressionBody: null); + expressionBody: null).WithLeadingBlankLine(); // /// // /// Gets the type that is wrapped by the given wrapper. diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseObjectCreationExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseObjectCreationExpressionSyntaxWrapper.g.cs index 09f028b174..74f02aab9a 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseObjectCreationExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseObjectCreationExpressionSyntaxWrapper.g.cs @@ -13,13 +13,16 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax"; private static readonly Type WrappedType; + private static readonly Func NewKeywordAccessor; private static readonly Func ArgumentListAccessor; private static readonly Func InitializerAccessor; private static readonly Func WithNewKeywordAccessor; private static readonly Func WithArgumentListAccessor; private static readonly Func WithInitializerAccessor; + private readonly ExpressionSyntax node; + static BaseObjectCreationExpressionSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(BaseObjectCreationExpressionSyntaxWrapper)); @@ -37,6 +40,7 @@ private BaseObjectCreationExpressionSyntaxWrapper(ExpressionSyntax node) } public ExpressionSyntax SyntaxNode => this.node; + public SyntaxToken NewKeyword { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseParameterSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseParameterSyntaxWrapper.g.cs index a063ac1f6e..139edba394 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseParameterSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BaseParameterSyntaxWrapper.g.cs @@ -13,13 +13,16 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax"; private static readonly Type WrappedType; + private static readonly Func> AttributeListsAccessor; private static readonly Func ModifiersAccessor; private static readonly Func TypeAccessor; private static readonly Func, CSharpSyntaxNode> WithAttributeListsAccessor; private static readonly Func WithModifiersAccessor; private static readonly Func WithTypeAccessor; + private readonly CSharpSyntaxNode node; + static BaseParameterSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(BaseParameterSyntaxWrapper)); @@ -37,6 +40,7 @@ private BaseParameterSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public SyntaxList AttributeLists { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BinaryPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BinaryPatternSyntaxWrapper.g.cs index 2ea835a418..305a42df27 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BinaryPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/BinaryPatternSyntaxWrapper.g.cs @@ -13,13 +13,16 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax"; private static readonly Type WrappedType; + private static readonly Func LeftAccessor; private static readonly Func OperatorTokenAccessor; private static readonly Func RightAccessor; private static readonly Func WithLeftAccessor; private static readonly Func WithOperatorTokenAccessor; private static readonly Func WithRightAccessor; + private readonly CSharpSyntaxNode node; + static BinaryPatternSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(BinaryPatternSyntaxWrapper)); @@ -37,6 +40,7 @@ private BinaryPatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public PatternSyntaxWrapper Left { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CasePatternSwitchLabelSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CasePatternSwitchLabelSyntaxWrapper.g.cs index f6c6405a43..927e6dea97 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CasePatternSwitchLabelSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CasePatternSwitchLabelSyntaxWrapper.g.cs @@ -13,13 +13,16 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.CasePatternSwitchLabelSyntax"; private static readonly Type WrappedType; + private static readonly Func PatternAccessor; private static readonly Func WhenClauseAccessor; private static readonly Func WithKeywordAccessor; private static readonly Func WithPatternAccessor; private static readonly Func WithWhenClauseAccessor; private static readonly Func WithColonTokenAccessor; + private readonly SwitchLabelSyntax node; + static CasePatternSwitchLabelSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(CasePatternSwitchLabelSyntaxWrapper)); @@ -37,6 +40,7 @@ private CasePatternSwitchLabelSyntaxWrapper(SwitchLabelSyntax node) } public SwitchLabelSyntax SyntaxNode => this.node; + public SyntaxToken Keyword { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CommonForEachStatementSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CommonForEachStatementSyntaxWrapper.g.cs index 1ef7d1d26b..8e91cd2ef8 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CommonForEachStatementSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/CommonForEachStatementSyntaxWrapper.g.cs @@ -13,6 +13,7 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.CommonForEachStatementSyntax"; private static readonly Type WrappedType; + private static readonly Func AwaitKeywordAccessor; private static readonly Func ForEachKeywordAccessor; private static readonly Func OpenParenTokenAccessor; @@ -27,7 +28,9 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func WithExpressionAccessor; private static readonly Func WithCloseParenTokenAccessor; private static readonly Func WithStatementAccessor; + private readonly StatementSyntax node; + static CommonForEachStatementSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(CommonForEachStatementSyntaxWrapper)); @@ -53,6 +56,7 @@ private CommonForEachStatementSyntaxWrapper(StatementSyntax node) } public StatementSyntax SyntaxNode => this.node; + public SyntaxToken AwaitKeyword { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ConstantPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ConstantPatternSyntaxWrapper.g.cs index a654a76471..b9edf71fbf 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ConstantPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ConstantPatternSyntaxWrapper.g.cs @@ -13,9 +13,12 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.ConstantPatternSyntax"; private static readonly Type WrappedType; + private static readonly Func ExpressionAccessor; private static readonly Func WithExpressionAccessor; + private readonly CSharpSyntaxNode node; + static ConstantPatternSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(ConstantPatternSyntaxWrapper)); @@ -29,6 +32,7 @@ private ConstantPatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public ExpressionSyntax Expression { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationExpressionSyntaxWrapper.g.cs index 05faf453e0..a5feafe03a 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationExpressionSyntaxWrapper.g.cs @@ -13,11 +13,14 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationExpressionSyntax"; private static readonly Type WrappedType; + private static readonly Func TypeAccessor; private static readonly Func DesignationAccessor; private static readonly Func WithTypeAccessor; private static readonly Func WithDesignationAccessor; + private readonly ExpressionSyntax node; + static DeclarationExpressionSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(DeclarationExpressionSyntaxWrapper)); @@ -33,6 +36,7 @@ private DeclarationExpressionSyntaxWrapper(ExpressionSyntax node) } public ExpressionSyntax SyntaxNode => this.node; + public TypeSyntax Type { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationPatternSyntaxWrapper.g.cs index 0b965518a6..f0dee0a3e3 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DeclarationPatternSyntaxWrapper.g.cs @@ -13,11 +13,14 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.DeclarationPatternSyntax"; private static readonly Type WrappedType; + private static readonly Func TypeAccessor; private static readonly Func DesignationAccessor; private static readonly Func WithTypeAccessor; private static readonly Func WithDesignationAccessor; + private readonly CSharpSyntaxNode node; + static DeclarationPatternSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(DeclarationPatternSyntaxWrapper)); @@ -33,6 +36,7 @@ private DeclarationPatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public TypeSyntax Type { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DefaultConstraintSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DefaultConstraintSyntaxWrapper.g.cs index a1a1b9f6ba..905714e838 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DefaultConstraintSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DefaultConstraintSyntaxWrapper.g.cs @@ -13,9 +13,12 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.DefaultConstraintSyntax"; private static readonly Type WrappedType; + private static readonly Func DefaultKeywordAccessor; private static readonly Func WithDefaultKeywordAccessor; + private readonly TypeParameterConstraintSyntax node; + static DefaultConstraintSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(DefaultConstraintSyntaxWrapper)); @@ -29,6 +32,7 @@ private DefaultConstraintSyntaxWrapper(TypeParameterConstraintSyntax node) } public TypeParameterConstraintSyntax SyntaxNode => this.node; + public SyntaxToken DefaultKeyword { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardDesignationSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardDesignationSyntaxWrapper.g.cs index 3ec19a92cd..c2a8eb70bb 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardDesignationSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardDesignationSyntaxWrapper.g.cs @@ -13,9 +13,12 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.DiscardDesignationSyntax"; private static readonly Type WrappedType; + private static readonly Func UnderscoreTokenAccessor; private static readonly Func WithUnderscoreTokenAccessor; + private readonly CSharpSyntaxNode node; + static DiscardDesignationSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(DiscardDesignationSyntaxWrapper)); @@ -29,6 +32,7 @@ private DiscardDesignationSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public SyntaxToken UnderscoreToken { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardPatternSyntaxWrapper.g.cs index 3a62aabb74..992c06ae67 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/DiscardPatternSyntaxWrapper.g.cs @@ -13,9 +13,12 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.DiscardPatternSyntax"; private static readonly Type WrappedType; + private static readonly Func UnderscoreTokenAccessor; private static readonly Func WithUnderscoreTokenAccessor; + private readonly CSharpSyntaxNode node; + static DiscardPatternSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(DiscardPatternSyntaxWrapper)); @@ -29,6 +32,7 @@ private DiscardPatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public SyntaxToken UnderscoreToken { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ExpressionOrPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ExpressionOrPatternSyntaxWrapper.g.cs index 24b6df8d96..5c4ae69d79 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ExpressionOrPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ExpressionOrPatternSyntaxWrapper.g.cs @@ -13,7 +13,9 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionOrPatternSyntax"; private static readonly Type WrappedType; + private readonly CSharpSyntaxNode node; + static ExpressionOrPatternSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(ExpressionOrPatternSyntaxWrapper)); @@ -25,6 +27,7 @@ private ExpressionOrPatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static explicit operator ExpressionOrPatternSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ForEachVariableStatementSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ForEachVariableStatementSyntaxWrapper.g.cs index fc36797243..49c71ed604 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ForEachVariableStatementSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ForEachVariableStatementSyntaxWrapper.g.cs @@ -13,6 +13,7 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.ForEachVariableStatementSyntax"; private static readonly Type WrappedType; + private static readonly Func VariableAccessor; private static readonly Func, StatementSyntax> WithAttributeListsAccessor; private static readonly Func WithAwaitKeywordAccessor; @@ -23,7 +24,9 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func WithExpressionAccessor; private static readonly Func WithCloseParenTokenAccessor; private static readonly Func WithStatementAccessor; + private readonly StatementSyntax node; + static ForEachVariableStatementSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(ForEachVariableStatementSyntaxWrapper)); @@ -45,6 +48,7 @@ private ForEachVariableStatementSyntaxWrapper(StatementSyntax node) } public StatementSyntax SyntaxNode => this.node; + public SyntaxList AttributeLists { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerCallingConventionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerCallingConventionSyntaxWrapper.g.cs index 52caa13bbc..99b4ba222c 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerCallingConventionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerCallingConventionSyntaxWrapper.g.cs @@ -13,11 +13,14 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax"; private static readonly Type WrappedType; + private static readonly Func ManagedOrUnmanagedKeywordAccessor; private static readonly Func UnmanagedCallingConventionListAccessor; private static readonly Func WithManagedOrUnmanagedKeywordAccessor; private static readonly Func WithUnmanagedCallingConventionListAccessor; + private readonly CSharpSyntaxNode node; + static FunctionPointerCallingConventionSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(FunctionPointerCallingConventionSyntaxWrapper)); @@ -33,6 +36,7 @@ private FunctionPointerCallingConventionSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public SyntaxToken ManagedOrUnmanagedKeyword { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterListSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterListSyntaxWrapper.g.cs index 76f685cf2a..f20723c867 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterListSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterListSyntaxWrapper.g.cs @@ -13,13 +13,16 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax"; private static readonly Type WrappedType; + private static readonly Func LessThanTokenAccessor; private static readonly Func> ParametersAccessor; private static readonly Func GreaterThanTokenAccessor; private static readonly Func WithLessThanTokenAccessor; private static readonly Func, CSharpSyntaxNode> WithParametersAccessor; private static readonly Func WithGreaterThanTokenAccessor; + private readonly CSharpSyntaxNode node; + static FunctionPointerParameterListSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(FunctionPointerParameterListSyntaxWrapper)); @@ -37,6 +40,7 @@ private FunctionPointerParameterListSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public SyntaxToken LessThanToken { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterSyntaxWrapper.g.cs index 564e70d5d9..46968ca701 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerParameterSyntaxWrapper.g.cs @@ -16,7 +16,9 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func, CSharpSyntaxNode> WithAttributeListsAccessor; private static readonly Func WithModifiersAccessor; private static readonly Func WithTypeAccessor; + private readonly CSharpSyntaxNode node; + static FunctionPointerParameterSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(FunctionPointerParameterSyntaxWrapper)); @@ -31,6 +33,7 @@ private FunctionPointerParameterSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public SyntaxList AttributeLists { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerTypeSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerTypeSyntaxWrapper.g.cs index 908a1994e7..5d1cb86b55 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerTypeSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerTypeSyntaxWrapper.g.cs @@ -13,6 +13,7 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax"; private static readonly Type WrappedType; + private static readonly Func DelegateKeywordAccessor; private static readonly Func AsteriskTokenAccessor; private static readonly Func CallingConventionAccessor; @@ -21,7 +22,9 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func WithAsteriskTokenAccessor; private static readonly Func WithCallingConventionAccessor; private static readonly Func WithParameterListAccessor; + private readonly TypeSyntax node; + static FunctionPointerTypeSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(FunctionPointerTypeSyntaxWrapper)); @@ -41,6 +44,7 @@ private FunctionPointerTypeSyntaxWrapper(TypeSyntax node) } public TypeSyntax SyntaxNode => this.node; + public SyntaxToken DelegateKeyword { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionListSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionListSyntaxWrapper.g.cs index 341fd376aa..d4660617e3 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionListSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionListSyntaxWrapper.g.cs @@ -13,13 +13,16 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax"; private static readonly Type WrappedType; + private static readonly Func OpenBracketTokenAccessor; private static readonly Func> CallingConventionsAccessor; private static readonly Func CloseBracketTokenAccessor; private static readonly Func WithOpenBracketTokenAccessor; private static readonly Func, CSharpSyntaxNode> WithCallingConventionsAccessor; private static readonly Func WithCloseBracketTokenAccessor; + private readonly CSharpSyntaxNode node; + static FunctionPointerUnmanagedCallingConventionListSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(FunctionPointerUnmanagedCallingConventionListSyntaxWrapper)); @@ -37,6 +40,7 @@ private FunctionPointerUnmanagedCallingConventionListSyntaxWrapper(CSharpSyntaxN } public CSharpSyntaxNode SyntaxNode => this.node; + public SyntaxToken OpenBracketToken { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionSyntaxWrapper.g.cs index cd800d6989..da6a24f7fe 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/FunctionPointerUnmanagedCallingConventionSyntaxWrapper.g.cs @@ -13,9 +13,12 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax"; private static readonly Type WrappedType; + private static readonly Func NameAccessor; private static readonly Func WithNameAccessor; + private readonly CSharpSyntaxNode node; + static FunctionPointerUnmanagedCallingConventionSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(FunctionPointerUnmanagedCallingConventionSyntaxWrapper)); @@ -29,6 +32,7 @@ private FunctionPointerUnmanagedCallingConventionSyntaxWrapper(CSharpSyntaxNode } public CSharpSyntaxNode SyntaxNode => this.node; + public SyntaxToken Name { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitObjectCreationExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitObjectCreationExpressionSyntaxWrapper.g.cs index 5fe6a3e14f..a5c2dab625 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitObjectCreationExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitObjectCreationExpressionSyntaxWrapper.g.cs @@ -16,7 +16,9 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func WithNewKeywordAccessor; private static readonly Func WithArgumentListAccessor; private static readonly Func WithInitializerAccessor; + private readonly ExpressionSyntax node; + static ImplicitObjectCreationExpressionSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(ImplicitObjectCreationExpressionSyntaxWrapper)); @@ -31,6 +33,7 @@ private ImplicitObjectCreationExpressionSyntaxWrapper(ExpressionSyntax node) } public ExpressionSyntax SyntaxNode => this.node; + public SyntaxToken NewKeyword { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.g.cs index d9f1a213a6..0cdf569f2b 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ImplicitStackAllocArrayCreationExpressionSyntaxWrapper.g.cs @@ -13,6 +13,7 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitStackAllocArrayCreationExpressionSyntax"; private static readonly Type WrappedType; + private static readonly Func StackAllocKeywordAccessor; private static readonly Func OpenBracketTokenAccessor; private static readonly Func CloseBracketTokenAccessor; @@ -21,7 +22,9 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func WithOpenBracketTokenAccessor; private static readonly Func WithCloseBracketTokenAccessor; private static readonly Func WithInitializerAccessor; + private readonly ExpressionSyntax node; + static ImplicitStackAllocArrayCreationExpressionSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(ImplicitStackAllocArrayCreationExpressionSyntaxWrapper)); @@ -41,6 +44,7 @@ private ImplicitStackAllocArrayCreationExpressionSyntaxWrapper(ExpressionSyntax } public ExpressionSyntax SyntaxNode => this.node; + public SyntaxToken StackAllocKeyword { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/IsPatternExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/IsPatternExpressionSyntaxWrapper.g.cs index b5a770d8de..d71a757a35 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/IsPatternExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/IsPatternExpressionSyntaxWrapper.g.cs @@ -13,13 +13,16 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.IsPatternExpressionSyntax"; private static readonly Type WrappedType; + private static readonly Func ExpressionAccessor; private static readonly Func IsKeywordAccessor; private static readonly Func PatternAccessor; private static readonly Func WithExpressionAccessor; private static readonly Func WithIsKeywordAccessor; private static readonly Func WithPatternAccessor; + private readonly ExpressionSyntax node; + static IsPatternExpressionSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(IsPatternExpressionSyntaxWrapper)); @@ -37,6 +40,7 @@ private IsPatternExpressionSyntaxWrapper(ExpressionSyntax node) } public ExpressionSyntax SyntaxNode => this.node; + public ExpressionSyntax Expression { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/LocalFunctionStatementSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/LocalFunctionStatementSyntaxWrapper.g.cs index 29458dbb54..e1940b11cc 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/LocalFunctionStatementSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/LocalFunctionStatementSyntaxWrapper.g.cs @@ -13,6 +13,7 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.LocalFunctionStatementSyntax"; private static readonly Type WrappedType; + private static readonly Func ModifiersAccessor; private static readonly Func ReturnTypeAccessor; private static readonly Func IdentifierAccessor; @@ -32,7 +33,9 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func WithBodyAccessor; private static readonly Func WithExpressionBodyAccessor; private static readonly Func WithSemicolonTokenAccessor; + private readonly StatementSyntax node; + static LocalFunctionStatementSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(LocalFunctionStatementSyntaxWrapper)); @@ -63,6 +66,7 @@ private LocalFunctionStatementSyntaxWrapper(StatementSyntax node) } public StatementSyntax SyntaxNode => this.node; + public SyntaxList AttributeLists { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/NullableDirectiveTriviaSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/NullableDirectiveTriviaSyntaxWrapper.g.cs index a458688f54..5c6bfd9d7e 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/NullableDirectiveTriviaSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/NullableDirectiveTriviaSyntaxWrapper.g.cs @@ -13,6 +13,7 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.NullableDirectiveTriviaSyntax"; private static readonly Type WrappedType; + private static readonly Func NullableKeywordAccessor; private static readonly Func SettingTokenAccessor; private static readonly Func TargetTokenAccessor; @@ -22,7 +23,9 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func WithTargetTokenAccessor; private static readonly Func WithEndOfDirectiveTokenAccessor; private static readonly Func WithIsActiveAccessor; + private readonly DirectiveTriviaSyntax node; + static NullableDirectiveTriviaSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(NullableDirectiveTriviaSyntaxWrapper)); @@ -43,6 +46,7 @@ private NullableDirectiveTriviaSyntaxWrapper(DirectiveTriviaSyntax node) } public DirectiveTriviaSyntax SyntaxNode => this.node; + public SyntaxToken HashToken { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedPatternSyntaxWrapper.g.cs index bb365ccfde..2ebc2af84f 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedPatternSyntaxWrapper.g.cs @@ -13,13 +13,16 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax"; private static readonly Type WrappedType; + private static readonly Func OpenParenTokenAccessor; private static readonly Func PatternAccessor; private static readonly Func CloseParenTokenAccessor; private static readonly Func WithOpenParenTokenAccessor; private static readonly Func WithPatternAccessor; private static readonly Func WithCloseParenTokenAccessor; + private readonly CSharpSyntaxNode node; + static ParenthesizedPatternSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(ParenthesizedPatternSyntaxWrapper)); @@ -37,6 +40,7 @@ private ParenthesizedPatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public SyntaxToken OpenParenToken { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedVariableDesignationSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedVariableDesignationSyntaxWrapper.g.cs index 31d8a930db..d0b4aff675 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedVariableDesignationSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ParenthesizedVariableDesignationSyntaxWrapper.g.cs @@ -13,13 +13,16 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedVariableDesignationSyntax"; private static readonly Type WrappedType; + private static readonly Func OpenParenTokenAccessor; private static readonly Func> VariablesAccessor; private static readonly Func CloseParenTokenAccessor; private static readonly Func WithOpenParenTokenAccessor; private static readonly Func, CSharpSyntaxNode> WithVariablesAccessor; private static readonly Func WithCloseParenTokenAccessor; + private readonly CSharpSyntaxNode node; + static ParenthesizedVariableDesignationSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(ParenthesizedVariableDesignationSyntaxWrapper)); @@ -37,6 +40,7 @@ private ParenthesizedVariableDesignationSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public SyntaxToken OpenParenToken { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PatternSyntaxWrapper.g.cs index d3dd7da973..4b52b4bfe8 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PatternSyntaxWrapper.g.cs @@ -13,7 +13,9 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax"; private static readonly Type WrappedType; + private readonly CSharpSyntaxNode node; + static PatternSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(PatternSyntaxWrapper)); @@ -25,6 +27,7 @@ private PatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static explicit operator PatternSyntaxWrapper(ExpressionOrPatternSyntaxWrapper node) { return (PatternSyntaxWrapper)node.SyntaxNode; diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PositionalPatternClauseSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PositionalPatternClauseSyntaxWrapper.g.cs index 686bd9117b..d69bd45bfa 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PositionalPatternClauseSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PositionalPatternClauseSyntaxWrapper.g.cs @@ -13,13 +13,16 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.PositionalPatternClauseSyntax"; private static readonly Type WrappedType; + private static readonly Func OpenParenTokenAccessor; private static readonly Func> SubpatternsAccessor; private static readonly Func CloseParenTokenAccessor; private static readonly Func WithOpenParenTokenAccessor; private static readonly Func, CSharpSyntaxNode> WithSubpatternsAccessor; private static readonly Func WithCloseParenTokenAccessor; + private readonly CSharpSyntaxNode node; + static PositionalPatternClauseSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(PositionalPatternClauseSyntaxWrapper)); @@ -37,6 +40,7 @@ private PositionalPatternClauseSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public SyntaxToken OpenParenToken { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PrimaryConstructorBaseTypeSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PrimaryConstructorBaseTypeSyntaxWrapper.g.cs index b1053e9b53..5d04961fc9 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PrimaryConstructorBaseTypeSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PrimaryConstructorBaseTypeSyntaxWrapper.g.cs @@ -13,10 +13,13 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax"; private static readonly Type WrappedType; + private static readonly Func ArgumentListAccessor; private static readonly Func WithTypeAccessor; private static readonly Func WithArgumentListAccessor; + private readonly BaseTypeSyntax node; + static PrimaryConstructorBaseTypeSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(PrimaryConstructorBaseTypeSyntaxWrapper)); @@ -31,6 +34,7 @@ private PrimaryConstructorBaseTypeSyntaxWrapper(BaseTypeSyntax node) } public BaseTypeSyntax SyntaxNode => this.node; + public TypeSyntax Type { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PropertyPatternClauseSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PropertyPatternClauseSyntaxWrapper.g.cs index 9a2f79db68..7d27a3d08a 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PropertyPatternClauseSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/PropertyPatternClauseSyntaxWrapper.g.cs @@ -13,13 +13,16 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.PropertyPatternClauseSyntax"; private static readonly Type WrappedType; + private static readonly Func OpenBraceTokenAccessor; private static readonly Func> SubpatternsAccessor; private static readonly Func CloseBraceTokenAccessor; private static readonly Func WithOpenBraceTokenAccessor; private static readonly Func, CSharpSyntaxNode> WithSubpatternsAccessor; private static readonly Func WithCloseBraceTokenAccessor; + private readonly CSharpSyntaxNode node; + static PropertyPatternClauseSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(PropertyPatternClauseSyntaxWrapper)); @@ -37,6 +40,7 @@ private PropertyPatternClauseSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public SyntaxToken OpenBraceToken { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RangeExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RangeExpressionSyntaxWrapper.g.cs index 166fd4ed81..97dd7d9311 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RangeExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RangeExpressionSyntaxWrapper.g.cs @@ -13,13 +13,16 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.RangeExpressionSyntax"; private static readonly Type WrappedType; + private static readonly Func LeftOperandAccessor; private static readonly Func OperatorTokenAccessor; private static readonly Func RightOperandAccessor; private static readonly Func WithLeftOperandAccessor; private static readonly Func WithOperatorTokenAccessor; private static readonly Func WithRightOperandAccessor; + private readonly ExpressionSyntax node; + static RangeExpressionSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(RangeExpressionSyntaxWrapper)); @@ -37,6 +40,7 @@ private RangeExpressionSyntaxWrapper(ExpressionSyntax node) } public ExpressionSyntax SyntaxNode => this.node; + public ExpressionSyntax LeftOperand { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecordDeclarationSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecordDeclarationSyntaxWrapper.g.cs index 887fc09777..bbcfc89a42 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecordDeclarationSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecordDeclarationSyntaxWrapper.g.cs @@ -13,6 +13,7 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax"; private static readonly Type WrappedType; + private static readonly Func ParameterListAccessor; private static readonly Func, TypeDeclarationSyntax> WithAttributeListsAccessor; private static readonly Func WithModifiersAccessor; @@ -26,7 +27,9 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func, TypeDeclarationSyntax> WithMembersAccessor; private static readonly Func WithCloseBraceTokenAccessor; private static readonly Func WithSemicolonTokenAccessor; + private readonly TypeDeclarationSyntax node; + static RecordDeclarationSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(RecordDeclarationSyntaxWrapper)); @@ -51,6 +54,7 @@ private RecordDeclarationSyntaxWrapper(TypeDeclarationSyntax node) } public TypeDeclarationSyntax SyntaxNode => this.node; + public SyntaxList AttributeLists { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecursivePatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecursivePatternSyntaxWrapper.g.cs index babe64fd6c..a805c3a82f 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecursivePatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RecursivePatternSyntaxWrapper.g.cs @@ -13,6 +13,7 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.RecursivePatternSyntax"; private static readonly Type WrappedType; + private static readonly Func TypeAccessor; private static readonly Func PositionalPatternClauseAccessor; private static readonly Func PropertyPatternClauseAccessor; @@ -21,7 +22,9 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func WithPositionalPatternClauseAccessor; private static readonly Func WithPropertyPatternClauseAccessor; private static readonly Func WithDesignationAccessor; + private readonly CSharpSyntaxNode node; + static RecursivePatternSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(RecursivePatternSyntaxWrapper)); @@ -41,6 +44,7 @@ private RecursivePatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public TypeSyntax Type { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefExpressionSyntaxWrapper.g.cs index 77c4d3e321..66ccf75292 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefExpressionSyntaxWrapper.g.cs @@ -13,11 +13,14 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.RefExpressionSyntax"; private static readonly Type WrappedType; + private static readonly Func RefKeywordAccessor; private static readonly Func ExpressionAccessor; private static readonly Func WithRefKeywordAccessor; private static readonly Func WithExpressionAccessor; + private readonly ExpressionSyntax node; + static RefExpressionSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(RefExpressionSyntaxWrapper)); @@ -33,6 +36,7 @@ private RefExpressionSyntaxWrapper(ExpressionSyntax node) } public ExpressionSyntax SyntaxNode => this.node; + public SyntaxToken RefKeyword { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefTypeSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefTypeSyntaxWrapper.g.cs index 769f658fc8..aa22346716 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefTypeSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RefTypeSyntaxWrapper.g.cs @@ -13,13 +13,16 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.RefTypeSyntax"; private static readonly Type WrappedType; + private static readonly Func RefKeywordAccessor; private static readonly Func ReadOnlyKeywordAccessor; private static readonly Func TypeAccessor; private static readonly Func WithRefKeywordAccessor; private static readonly Func WithReadOnlyKeywordAccessor; private static readonly Func WithTypeAccessor; + private readonly TypeSyntax node; + static RefTypeSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(RefTypeSyntaxWrapper)); @@ -37,6 +40,7 @@ private RefTypeSyntaxWrapper(TypeSyntax node) } public TypeSyntax SyntaxNode => this.node; + public SyntaxToken RefKeyword { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RelationalPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RelationalPatternSyntaxWrapper.g.cs index 7d71552e97..70d4ba4bce 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RelationalPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/RelationalPatternSyntaxWrapper.g.cs @@ -13,11 +13,14 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.RelationalPatternSyntax"; private static readonly Type WrappedType; + private static readonly Func OperatorTokenAccessor; private static readonly Func ExpressionAccessor; private static readonly Func WithOperatorTokenAccessor; private static readonly Func WithExpressionAccessor; + private readonly CSharpSyntaxNode node; + static RelationalPatternSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(RelationalPatternSyntaxWrapper)); @@ -33,6 +36,7 @@ private RelationalPatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public SyntaxToken OperatorToken { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SingleVariableDesignationSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SingleVariableDesignationSyntaxWrapper.g.cs index c27b2f3a07..95bf87c9d9 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SingleVariableDesignationSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SingleVariableDesignationSyntaxWrapper.g.cs @@ -13,9 +13,12 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax"; private static readonly Type WrappedType; + private static readonly Func IdentifierAccessor; private static readonly Func WithIdentifierAccessor; + private readonly CSharpSyntaxNode node; + static SingleVariableDesignationSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(SingleVariableDesignationSyntaxWrapper)); @@ -29,6 +32,7 @@ private SingleVariableDesignationSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public SyntaxToken Identifier { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SubpatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SubpatternSyntaxWrapper.g.cs index e8db37b078..d7beccbc3d 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SubpatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SubpatternSyntaxWrapper.g.cs @@ -13,11 +13,14 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax"; private static readonly Type WrappedType; + private static readonly Func NameColonAccessor; private static readonly Func PatternAccessor; private static readonly Func WithNameColonAccessor; private static readonly Func WithPatternAccessor; + private readonly CSharpSyntaxNode node; + static SubpatternSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(SubpatternSyntaxWrapper)); @@ -33,6 +36,7 @@ private SubpatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public NameColonSyntax NameColon { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionArmSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionArmSyntaxWrapper.g.cs index 1f7bf7d380..d7216f44bb 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionArmSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionArmSyntaxWrapper.g.cs @@ -13,6 +13,7 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionArmSyntax"; private static readonly Type WrappedType; + private static readonly Func PatternAccessor; private static readonly Func WhenClauseAccessor; private static readonly Func EqualsGreaterThanTokenAccessor; @@ -21,7 +22,9 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func WithWhenClauseAccessor; private static readonly Func WithEqualsGreaterThanTokenAccessor; private static readonly Func WithExpressionAccessor; + private readonly CSharpSyntaxNode node; + static SwitchExpressionArmSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(SwitchExpressionArmSyntaxWrapper)); @@ -41,6 +44,7 @@ private SwitchExpressionArmSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public PatternSyntaxWrapper Pattern { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionSyntaxWrapper.g.cs index f35bfa6f81..85a737efb5 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SwitchExpressionSyntaxWrapper.g.cs @@ -13,6 +13,7 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.SwitchExpressionSyntax"; private static readonly Type WrappedType; + private static readonly Func GoverningExpressionAccessor; private static readonly Func SwitchKeywordAccessor; private static readonly Func OpenBraceTokenAccessor; @@ -23,7 +24,9 @@ namespace StyleCop.Analyzers.Lightup private static readonly Func WithOpenBraceTokenAccessor; private static readonly Func, ExpressionSyntax> WithArmsAccessor; private static readonly Func WithCloseBraceTokenAccessor; + private readonly ExpressionSyntax node; + static SwitchExpressionSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(SwitchExpressionSyntaxWrapper)); @@ -45,6 +48,7 @@ private SwitchExpressionSyntaxWrapper(ExpressionSyntax node) } public ExpressionSyntax SyntaxNode => this.node; + public ExpressionSyntax GoverningExpression { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SyntaxWrapperHelper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SyntaxWrapperHelper.g.cs index f6beee5dec..85f0161731 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SyntaxWrapperHelper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/SyntaxWrapperHelper.g.cs @@ -12,10 +12,12 @@ namespace StyleCop.Analyzers.Lightup internal static class SyntaxWrapperHelper { private static readonly ImmutableDictionary WrappedTypes; + static SyntaxWrapperHelper() { var csharpCodeAnalysisAssembly = typeof(CSharpSyntaxNode).GetTypeInfo().Assembly; var builder = ImmutableDictionary.CreateBuilder(); + builder.Add(typeof(BaseObjectCreationExpressionSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(BaseObjectCreationExpressionSyntaxWrapper.WrappedTypeName)); builder.Add(typeof(BaseParameterSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(BaseParameterSyntaxWrapper.WrappedTypeName)); builder.Add(typeof(BinaryPatternSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(BinaryPatternSyntaxWrapper.WrappedTypeName)); @@ -67,6 +69,7 @@ static SyntaxWrapperHelper() builder.Add(typeof(VarPatternSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(VarPatternSyntaxWrapper.WrappedTypeName)); builder.Add(typeof(WhenClauseSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(WhenClauseSyntaxWrapper.WrappedTypeName)); builder.Add(typeof(WithExpressionSyntaxWrapper), csharpCodeAnalysisAssembly.GetType(WithExpressionSyntaxWrapper.WrappedTypeName)); + WrappedTypes = builder.ToImmutable(); } diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ThrowExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ThrowExpressionSyntaxWrapper.g.cs index c52368cc74..d85d4613ea 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ThrowExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/ThrowExpressionSyntaxWrapper.g.cs @@ -13,11 +13,14 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.ThrowExpressionSyntax"; private static readonly Type WrappedType; + private static readonly Func ThrowKeywordAccessor; private static readonly Func ExpressionAccessor; private static readonly Func WithThrowKeywordAccessor; private static readonly Func WithExpressionAccessor; + private readonly ExpressionSyntax node; + static ThrowExpressionSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(ThrowExpressionSyntaxWrapper)); @@ -33,6 +36,7 @@ private ThrowExpressionSyntaxWrapper(ExpressionSyntax node) } public ExpressionSyntax SyntaxNode => this.node; + public SyntaxToken ThrowKeyword { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleElementSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleElementSyntaxWrapper.g.cs index 35b045a7c2..508c25cf4d 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleElementSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleElementSyntaxWrapper.g.cs @@ -13,11 +13,14 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax"; private static readonly Type WrappedType; + private static readonly Func TypeAccessor; private static readonly Func IdentifierAccessor; private static readonly Func WithTypeAccessor; private static readonly Func WithIdentifierAccessor; + private readonly CSharpSyntaxNode node; + static TupleElementSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(TupleElementSyntaxWrapper)); @@ -33,6 +36,7 @@ private TupleElementSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public TypeSyntax Type { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleExpressionSyntaxWrapper.g.cs index 8c91cc021a..e05a152c98 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleExpressionSyntaxWrapper.g.cs @@ -13,13 +13,16 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.TupleExpressionSyntax"; private static readonly Type WrappedType; + private static readonly Func OpenParenTokenAccessor; private static readonly Func> ArgumentsAccessor; private static readonly Func CloseParenTokenAccessor; private static readonly Func WithOpenParenTokenAccessor; private static readonly Func, ExpressionSyntax> WithArgumentsAccessor; private static readonly Func WithCloseParenTokenAccessor; + private readonly ExpressionSyntax node; + static TupleExpressionSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(TupleExpressionSyntaxWrapper)); @@ -37,6 +40,7 @@ private TupleExpressionSyntaxWrapper(ExpressionSyntax node) } public ExpressionSyntax SyntaxNode => this.node; + public SyntaxToken OpenParenToken { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleTypeSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleTypeSyntaxWrapper.g.cs index 4ce129d8cb..d0117fc618 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleTypeSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TupleTypeSyntaxWrapper.g.cs @@ -13,13 +13,16 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax"; private static readonly Type WrappedType; + private static readonly Func OpenParenTokenAccessor; private static readonly Func> ElementsAccessor; private static readonly Func CloseParenTokenAccessor; private static readonly Func WithOpenParenTokenAccessor; private static readonly Func, TypeSyntax> WithElementsAccessor; private static readonly Func WithCloseParenTokenAccessor; + private readonly TypeSyntax node; + static TupleTypeSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(TupleTypeSyntaxWrapper)); @@ -37,6 +40,7 @@ private TupleTypeSyntaxWrapper(TypeSyntax node) } public TypeSyntax SyntaxNode => this.node; + public SyntaxToken OpenParenToken { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TypePatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TypePatternSyntaxWrapper.g.cs index b4066b6da5..4bf6195c23 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TypePatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/TypePatternSyntaxWrapper.g.cs @@ -13,9 +13,12 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.TypePatternSyntax"; private static readonly Type WrappedType; + private static readonly Func TypeAccessor; private static readonly Func WithTypeAccessor; + private readonly CSharpSyntaxNode node; + static TypePatternSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(TypePatternSyntaxWrapper)); @@ -29,6 +32,7 @@ private TypePatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public TypeSyntax Type { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/UnaryPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/UnaryPatternSyntaxWrapper.g.cs index b20510764d..51d2560c16 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/UnaryPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/UnaryPatternSyntaxWrapper.g.cs @@ -13,11 +13,14 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax"; private static readonly Type WrappedType; + private static readonly Func OperatorTokenAccessor; private static readonly Func PatternAccessor; private static readonly Func WithOperatorTokenAccessor; private static readonly Func WithPatternAccessor; + private readonly CSharpSyntaxNode node; + static UnaryPatternSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(UnaryPatternSyntaxWrapper)); @@ -33,6 +36,7 @@ private UnaryPatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public SyntaxToken OperatorToken { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VarPatternSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VarPatternSyntaxWrapper.g.cs index 3aa513637d..13784a24aa 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VarPatternSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VarPatternSyntaxWrapper.g.cs @@ -13,11 +13,14 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.VarPatternSyntax"; private static readonly Type WrappedType; + private static readonly Func VarKeywordAccessor; private static readonly Func DesignationAccessor; private static readonly Func WithVarKeywordAccessor; private static readonly Func WithDesignationAccessor; + private readonly CSharpSyntaxNode node; + static VarPatternSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(VarPatternSyntaxWrapper)); @@ -33,6 +36,7 @@ private VarPatternSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public SyntaxToken VarKeyword { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VariableDesignationSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VariableDesignationSyntaxWrapper.g.cs index 986f2ccf7c..0cf306f9b5 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VariableDesignationSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/VariableDesignationSyntaxWrapper.g.cs @@ -13,7 +13,9 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.VariableDesignationSyntax"; private static readonly Type WrappedType; + private readonly CSharpSyntaxNode node; + static VariableDesignationSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(VariableDesignationSyntaxWrapper)); @@ -25,6 +27,7 @@ private VariableDesignationSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public static explicit operator VariableDesignationSyntaxWrapper(SyntaxNode node) { if (node == null) diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WhenClauseSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WhenClauseSyntaxWrapper.g.cs index 75d595a1a5..19b9e11615 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WhenClauseSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WhenClauseSyntaxWrapper.g.cs @@ -13,11 +13,14 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax"; private static readonly Type WrappedType; + private static readonly Func WhenKeywordAccessor; private static readonly Func ConditionAccessor; private static readonly Func WithWhenKeywordAccessor; private static readonly Func WithConditionAccessor; + private readonly CSharpSyntaxNode node; + static WhenClauseSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(WhenClauseSyntaxWrapper)); @@ -33,6 +36,7 @@ private WhenClauseSyntaxWrapper(CSharpSyntaxNode node) } public CSharpSyntaxNode SyntaxNode => this.node; + public SyntaxToken WhenKeyword { get diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WithExpressionSyntaxWrapper.g.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WithExpressionSyntaxWrapper.g.cs index 0474cca4d6..ec72fe6813 100644 --- a/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WithExpressionSyntaxWrapper.g.cs +++ b/StyleCop.Analyzers/StyleCop.Analyzers/Lightup/.generated/StyleCop.Analyzers.CodeGeneration/StyleCop.Analyzers.CodeGeneration.SyntaxLightupGenerator/WithExpressionSyntaxWrapper.g.cs @@ -13,13 +13,16 @@ namespace StyleCop.Analyzers.Lightup { internal const string WrappedTypeName = "Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax"; private static readonly Type WrappedType; + private static readonly Func ExpressionAccessor; private static readonly Func WithKeywordAccessor; private static readonly Func InitializerAccessor; private static readonly Func WithExpressionAccessor; private static readonly Func WithWithKeywordAccessor; private static readonly Func WithInitializerAccessor; + private readonly ExpressionSyntax node; + static WithExpressionSyntaxWrapper() { WrappedType = SyntaxWrapperHelper.GetWrappedType(typeof(WithExpressionSyntaxWrapper)); @@ -37,6 +40,7 @@ private WithExpressionSyntaxWrapper(ExpressionSyntax node) } public ExpressionSyntax SyntaxNode => this.node; + public ExpressionSyntax Expression { get