JetBrains.ReSharper.Refactorings.CSharp
Deconstruction is only supported since C#7.
Mixed variables/declarations deconstruction is only supported since C#10.
This method will convert unsupported deconstruction syntax into supported method call.
Then it will convert unsupported deconstruction of NET4.5 System.Tuple into assignments, if needed.
- `var _` is only supported discard for C#6 and earlier
- All declarations are disallowed for simplicity.
- Only single-variable declaration expressions are supported for now.
A context node of the invocation that was used to start the refactoring.
Containing type of .
Use during the refactoring instead.
null if is
empty (containing type of the invocation should be used)
or contains new class name (new class will be created during refactoring).
These data can't be passed via parameters and must be provided via [LoggerMessage] attribute
These data can't be passed via parameters and must be provided via [LoggerMessage] attribute
General class to encapsulate logic for extract method action
Returns ICSharpStatementsRange | ICSharpExpression | null
p -> m
return value only
return value, out parameter
value is defined in the method and can be returned but it has no usages outside.
ref parameter or a combination of value parameter and return value...
Do not pass this parameter at all
Result declaration
Constructor parameter to:
1. Initialized field/property
2. Base/derived/delegating constructor parameter
Add renames derived from field rename
Property to its backing field
This tool allows to classify an expression against various assignment-like syntaxes
and perform a SINGLE transformation on it (e.g. )
Helper is one-off, ONLY ONE METHOD CAN BE CALLED after per instance created.
X -> result = X
y = X -> y = result = X
var y = X -> var y = result = X
(a, b) = X -> (a, b) = result = X
Additionally can replace X with X.M access
X -> result = X
y = X -> result = X
var y = X -> result = X
(a, b) = X -> result = X
Additionally can replace X with X.M access
X; -> var result = X;
y = X; -> var result = y = X;
var y = X -> var y = result = X
(a, b) = X -> (a, b) = result = X
Additionally can replace X with X.M access.
This method doesn't move expression out from its statement.
X; -> var result = X;
y = X; -> var result = X;
var y = X; -> var result = X;
(a, b) = X; -> var result = X;
This method doesn't move expression out from its statement.
(X) -> X.V
var y = X; -> var y = X.V;
y = X -> y = X.V
(a, b) = X -> (a, b) = X.V
(X) -> ((t1, t2, oldResult) = X).oldResult
(y = X) -> ((t1, t2, y) = X).y
Calls for these cases:
var y = X; -> (t1, t2, var y) = X;
y = X; -> (t1, t2, y) = X;
(a, b) = X; -> (t1, t2, V) = X;
X; -> (t1, t2) = X;
X; -> (t1, var t2) = X;
var y = X; -> (t1, var t2) = X;
y = X -> (t1, t2) = X
(a, b) = X -> (t1, var t2) = X
Hack here: `var _` is allowed if `allowDeclarations=false`, look for it in CsTransformParameters
>
var y = X; -> X;
y = X -> X
(a, b) = X -> X
Appends additional assignment/declaration statement after.
Note that you CAN call this method several times on same helper instance.
Appends additional tuple assignment/declaration statement after.
Note that you CAN call this method several times on same helper instance.
null if there is a serious conflict
For C#6 and earlier and/or NETFW 4.5 this method DOES generate deconstructing assignments,
but uses discard designations (var _) instead of discard references (_) in older C#.
See to translate resulting code to the target version of C#/NETFW.
Create CS abstracts declaration