JetBrains.ReSharper.Feature.Services.CSharp

Rules over the SolveEntirely method.

true, if modified this solver, false otherwise

The entry point to getting different expression heuristics, that cover some of the more-or-less pre-solvable cases.

Some nodes have NextSibling set to null, because they are LAST children under some parent. This method finds the first node, if traversing from its argument towards the root, that has a non-null NextSibling property (the argument itself is included into the search)

Calculates completion range for the specified reference

Extract part of the physical file as context, which could be reparsed multiple times to check if some construct could be parsed in given context, or not

Checks whether the statement can be converted to expression body

Not null conversion struct if the conversion is possible, null if the conversion is impossible

Checks whether the block body can be converted to expression body considering that the heuristics of the code body are switched on ()

Checks if the "Expression-bodied" IExpressionBodyOwnerDeclaration can be in expression-body mode if the heuristic () is considered to be switched on.

True if it is OK that this IExpressionBodyOwnerDeclaration has expression body False if is should have had a block body, if heuristic is switched on

We want to detect the order of modifiers. Let's generalize this task: GIVEN: We have number of words (modifiers), we know the amount of them. We have a set of sentences each of them consists of these given words. Each word can occur one or zero times in one sentence. The words order in a sentence determine the relationship between modifiers. E.G. "private static readonly" means that "private" > "static", "private" > "readonly", "static" > "readonly" But on the other hand, we can have another case like "static private readonly", and this case conflicts with the first one. The idea is to determine possible relations between modifiers while analyzing given sentences. We can image it as a directed graph, where nodes are the modifiers, and connections represent the relationships between modifiers. The connection now is an integer number (weight), if it is less than zero (a ->(-4) -> b) then a less than b, if weight == 0 then a = b, if weight > 0 then a > b After we analyzed all sentences we managed to find, we can sort the array of modifiers (or only modifiers which were processed during sentences' analysis) with custom comparator which will use the relations from this graph.

ParentExpression is not equals to Expression.Parent (e.g. Expression.Parent = IParenthesizedExpression, than ParentExpression = IParenthesizedExpression.Parent)

Checks corner cases when we don't want to return For example, when the user prefers to use "var" then don't suggest removing type specification

Do not use directly, use instead

Expression statement with assignment is lifted if destination is simple lifted reference and source expression can be lifted.

x = x.M(); => x = x?.M();

Blocks are lifted if containing statements are all lifted.

Declaration statement is lifted if all it's variables are initialized by lifted expressions.

var t = x.M(); => var t = x?.M(); int i = x.Val; => int? i = x?.Val;

Expression statement is lifted if it's expression can be lifted.

x.M(); => x?.M();

If statement with no else block is lifted when condition is lifted (or if first of conjuncted conditions can be lifted).

if (x != null) { } if (x != null && ...) { }

If statement with negative check, no else statement and control flow jump as then statement.

if (x == null) return; if (x == null || ...) continue;

Jump statement (break/continue/return/goto/goto case/yield break) is lifted if merged.

return x.M(); => return x?.M();

Return statement is lifted if it's return value can be lifted and there is lifted jump statement to merge with.

return x.M(); => return x?.M();

Using statement is lifted if resource expression is lifted or all resource variables are initialized by lifted expressions.

using (var t = x.M()) { } => using (var t = x?.M()) { } using (x.M()) { } => using (x?.M()) { }

Checks if semantic will not be broken if the cast will be removed

Provides access to declared element instances of implicitly used types under caret e.g. - M(out var x); - var x = ...; - var (_, _) = ...; - x is var y;

Populate (appending to the end) the with members' dispose calls.

Block to populate Block to place helper functions to The last dispose statement that was inserted by this method, if any

Represents a resolved info about using directive.

An instance of does not hold a tree node and only contains all the necessary semantic info. can be used to get an instance of from

Calculates usage statistics of using directives in the specified project module.

Resolving of using directives is quite expensive. However most of the using directives are specified at top-level of file and instead of resolving reference name reference we can get the imported namespace by quering the symbol scope with method. With this idea in mind the implementation handles top-level using namespaces directives separately from all others directives and uses instead of . Only those imports which are used in more number of files than a calculated threshold are getting converted into . This optimization makes the calculating process ~3 times faster on a typical projects.

Represents name of imported namespace as a pair of extern alias and qualified name of namespace.

Represents name of imported namespace as a pair of extern alias and qualified name of namespace.

Implements interfaces

Type to implement interface for Interfaces to implement Post-execute action to run template for generated methods body

Implements interfaces

Declaration to implement interfaces Interfaces to implement

Root options page for the C# language options.

Offsets within this range allow showing parameter information.

Actual arguments of invocation. Convert them to nodes and use to find on which argument caret is.

Finds appropriate invocation seeking at the specified tree node

Returns Evaluation.

Use this only to draw debug data tip.

Values-literals, Numbers, chars, strings.

Reference type objects (classes).

Value type objects (structs) that not boxed.

Values with errors. (thrown exceptions, evaluation errors, etc)

Stopped state with selected node for continue prediction in the current stack frame IProperty2AutoChecker

'ConfigureAwait' calls are not analyzed. It is up to a developer to decide whether 'ConfigureAwait' call is needed or not in each specific case.

In this case project code will be treated as a library, therefore 'ConfigureAwait(false)' calls should be used in most cases, so ReSharper will analyze 'await' expressions and statements for missing 'ConfigureAwait(false)' calls.

In this case project code will be treated as a client code working heavily with UI, therefore 'ConfigureAwait(false)' calls are not needed, instead default task behaviour should be preferred, so ReSharper will analyze 'await' expressions and statements for redundant 'ConfigureAwait(true)' calls.

Try to build the tree range selection leaving it on the same tree level (i.e. don't walk to parent) Return null if such selection couldn't be built

Try to build selection from the given node

Represents '.AppendLine($"{expr,-42:format}")' part for interpolation syntax. Can't be used in the string.Format-like syntax. It's the equivalent for $"{expr,-42:format}{Environment.NewLine}" in string interpolation.

Represents '.AppendFormat("{0},-42:format", expr)' part for string.Format-like syntax or '.Append($"{expr,-42:format}")' for interpolation syntax. It's the equivalent for $"{expr,-42:format}" in string interpolation.

Represents '.AppendJoin(separator, parameters...)' part. It's the equivalent for $"{expr,-42:format}{Environment.NewLine}" in string interpolation

Represents '.AppendLine()' part. It's the equivalent for $"{Environment.NewLine}" in string interpolation

Represents '.AppendLine(something)' part. It's the equivalent for $"{something}{Environment.NewLine}" and $"something{Environment.NewLine}" in string interpolation

Represents '.Append(something)' part. It's the equivalent for $"{something}" and $"something" in string interpolation

Represents '.Append(str, 1, 2)' part. It's the equivalent for $"{str.Substring(1, 2)}" in string interpolation

Represents '.Append(parameters)' part. It's the equivalent for various string constructor patterns in string interpolation, such as $"{new string('a', 10)}", $"{new string(charArray)}", $"{new string(charArray, 1, 10)}" etc.

A token of a string expression that can be sliced or cut from the string.

A slice of a string expression. That is, a string expression coupled with a valid tree range that can span more than one token, where both offsets correspond to valid positions inside sliceable tokens or point to the start or end boundaries (but not to the middle) of a non-sliceable node, such as an interpolated string insert.

Produce a new string expression corresponding to this slice.

Describes a preferred way to cut a substring from a string expression.

Produce a concatenation if the original expression is a literal. If it's an interpolated string, make a new hole for the substring.

If possible, produce an interpolated string with a hole, as long as converting a simple literal to an interpolated string wouldn't lead to worse codegen. Currently that means said conversion is performed if the project is targeting C# 10+.

Always produce a concatenation, even if the original expression is an interpolated string.

Always produce an interpolated string with a hole, even if converting a simple literal to an interpolated string would lead to additional allocations.

A slice of a string expression token. That is, a sliceable token coupled with a valid tree range, where both left and right offsets correspond to valid character positions inside its value.

Produce a new string expression corresponding to this slice.

Produce a new string expression corresponding to this slice.

Cut a substring corresponding to this slice from the containing string expression. Depending on , it can produce a concatenation of multiple substrings or an interpolated string with a new hole.

Modifies the original string expression. The substring corresponding to the slice.

Special structural matcher if IElementMatcher underneath is in fact Placeholder matcher. Used for optimization in Daemon

Type entity ^

Type entity ^

Type entity ^^^

Type entity ^^

Type entity ^^^^

Type entity ^^^^^^

[NotNull] Type entity ^^^^^^^

[ItemNotNull] Type entity ^^^^^^^^^^^

Type<EmbeddedType> entity ^^^^^^^^^^^^

Type [] ^^^^^

Type [] [] ^^^

Check if this expression initializer field with given type to default value, i.e. could be safely omitted. This means '0' for integral types, default ctor for value types, null for reference types. NOTE: initializing with named constant is not counted as default! NOTE: initializing with the same value with different nullability i.e. 'default!' is no counted as default!

is expected to be a variable declared OUTSIDE . Consider using SLOWER method if this precondition is not guaranteed. This method resolves reference behind to and searches for its declarations to check it isn't a local variable of . Consider using FASTER method if you have resolved and it is guaranteed to be declared outside .

Builds interpolated string expression from literals, parts of literals, and raw text.

IMPLEMENTATION NOTES C# has three kind of string verbatimity: regular, verbatim, and raw. Specific implementation strategy is abstracted via . Until implementation is defined the raw text added through is collected in .

Don't search for nested deconstructions.

Include only "deepest" deconstructions where every component is deconstructed as deep as possible.

Basic + Deepest.

Include all deconstruction combination. There are mitigations to prevent combinatorial explosion. When certain threshold of combinations is reached lookup strategy is changed to 'Hybrid'.

This method checks if some expression is definitely is not a subject of C# definite assignment analysis. You can pass expressions in write context, like out argument value or assignment target expression.

This type allows to track the value for being "stable", not affected by some write/method call.

Creates foreach statement with original expression used as collection.

An expression to wrap. Indicates whether to use asynchronous foreach statement. Indicates whether original expression should not only be used as collection, but also should be replaced with a usage of iteration variable. For example, if original expression is 'expr' when argument is true: foreach (var x in expr) { x{caret}; } when argument is false: foreach (var x in expr) { {caret} } Indicates whether code style for foreach statement braces should be overriden to always use braces

Conversion contains a nested conversion and should be processed component by component

There is no conversion here

Conversion isn't valid and it can't be a deconstruction

Node which is used to contain if method removed the latter, null otherwise. null only when params argument itself is null null only when params argument itself is null

Prepares given statements range for surrounding with block, i.e. rearranges local declarations around the statements in a way to produce 3 groups of statements: external declarations (which are referenced outside the block range, including outer local functions) statements and inner local functions (which reference declarations which are placed among the statements) outer local functions (which are referenced outside the block range) For now, extracting of pattern variables and array initializers is not supported, so the is expected to respect their visibility scope. You can use CanExtract methods for checking such declarations.

Statements to rearrange declarations and functions from.

Local variable to usages or initializer...

This node is created when value tracking runs on property declaration.

This node is descendant of . It is expanded into return value of getter or 'value' parameter of setter.

Parameter to argument value