JetBrains.ReSharper.Psi.CSharp

returns array of dimensions, e.g. for 'new int[]' returns { 1 } for 'new int[10]' returns { 1 } for 'new int[,,,]' returns { 4 } for 'new int[,][,,][]' returns { 2, 3, 1 } for 'new int[5,6][,,][]' returns { 2, 3, 1 }

returns list of 'size' expressions for first dimension, e.g. for 'new int[]' returns { null } for 'new int[x]' returns { x } for 'new int[,,,]' returns { null, null, null, null } for 'new int[,][,,][]' returns { null, null } for 'new int[x + y,z][,,][]' returns { x + y, z } TODO: this is not implemented yet for 'new int[5,,6][,,][]' returns { 5, null, 6 }

Assignment is a weird beast now: `a = b` `a += b` `a ??= b` `a = ref b` `var (a, b) = c` `(a, b) = c; `(var a, var b) = c` `a?.b = c`

Insert given class member at the first safe place AFTER given token

Expression under constant pattern do implicitly converts to pattern's dispatch type, like "governing" type of 'switch' statement of expression operand type of 'is' expression. This property returns constant value of expression under pattern with the correct type and should generally be used instead of 's property value.

If argument is named, then returns reference to corresponding parameter. If argument is positional, then returns null

Gets the expression which uses the current expression as an operand.

Gets the statement which uses the current expression as an operand.

Check if the expression could be classified as a variable according to C# spec 5.4.

Check if the expression is L-value.

Replace this expression by the copy of the given expression. Insert parentheses if necessary.

The copy of given expression which was actually inserted into tree

Replace this namespace declaration by the copy of the given

The clone of the original namespace which was added into the tree

Returns all namespaces declared by this decslaration.


            namespace X {
              namespace Y.Z.W {} // (*)
            }

GetDeclaredNamespaces> for (*) returns X.Y.Z.W, X.Y.Z and X.Y in that order.

Gets the statement in which the given statement is located

Checks if this statement is valid embedded statement according to C# specs

Replace this statement in the tree by the copy of the given statement

The clone of the original statement which was added into the tree

This is low-level method when you need to insert directive in a specific place. It also doesn't account for comments and preprocessor directives. Consider using AddImport instead of it

This reference is NOT presented in GetReferencedAssemblyNames() list for this element It is in GetReferencedAssemblyNames() of corresponding ReferenceName

Since, C# 7.0 turned 'is' expression into a terrible mess, you should be ready for the following cases: 'x is int', 'x is T[]', 'x is T{U}' (generic type) Ordinary type-checking 'is' operator. Type operand will be parsed as without variable designation. property returns the type from . returns . 'x is T' Ordinary type-checking 'is' operator. Type operand will be parsed as a with as a constant expression, since there is no way to disambiguate constant pattern from simple type usage that looks like . property returns the type this is resolved into. property returns unresolved (not unknown) type in the case of unresolved T. would help with disambiguating this kind of type check from constant pattern matching, but it requires semantic resolution of T. returns . 'x is T t', 'x is T _' Pattern-matching 'is' with exposed via property. property returns type from this . returns true for such 'is' expression. returns . 'x is var t' Pattern-matching 'is' with exposed via property. property returns the type of left expression. returns true for such 'is' expression. returns . * 'x is null', 'x is 42' Pattern-matching 'is' with exposed via property. contains the constant value, implicitly converted to the type of expression and should be used instead of over expression. returns the type of . returns true for such 'is' expression. returns .

Get the type that is actually used for type check (if any) at runtime time. Return 'unknown type' for negated patterns.

Checks if the reference expression is semantically qualified or not (depends on some other terms to be resolved or resolves via global table). Returns 'false' if this reference expression can reference local variable. Returns 'true' for member access in subpattern `is { ReferenceExpression: pat }`.

Computes the governing type of the switch condition (according to p8.7.2 of C# spec) If the condition expression is of the integral type or enum, then this type is returned. Otherwise, there must be one and only one implicit conversion operator to integral type

Gets reference to named tuple component if there is an explicit or inferred name.

Returns reference to if tuple type component is named; otherwise returns null.

Get the list of type arguments. Corresponding item in list is null if none is written in the source code, for example: typeof(C<>)

Adds type parameter constraint to appropriate place. It's caller's responsibility to remove conflicting constraints.

C# spec, 17.2 Attribute specification

No target is specified

Unrecognized target

Exposes common members of 'await' constructs for resolve purposes. This interface is NOT intended to be used in PSI features, please use pattern matching over C# tree node instead.

'await' keyword range

The target type is an array:


             int[] a = [1, 2, 3];

The target type is a 'Span<T>':


            Span<int> a = [1, 2, 3];

The target type is a 'ReadOnlySpan<T>':


            ReadOnlySpan<int> b = [1, 2, 3];

The target type is a type with a builder method:


            [CollectionBuilder(typeof(ImmutableArray), "Create")]
            public struct ImmutableArray<T> { ... }
            ...
            public static class ImmutableArray
            {
             public static ImmutableArray<T> Create<T>(ReadOnlySpan<T> items) { ... }
            }
            ...
            ImmutableArray<int> a = [1, 2, 3];

The target type is a type that implements 'IEnumerable':


            public class MyCollection<T> : IEnumerable<T> // inherited from IEnumerable
            {
              public IEnumerator<T> GetEnumerator() { }
              IEnumerator IEnumerable.GetEnumerator() { }
              ...
            }
            ...
            MyCollection<int> a = [1, 2, 3];

The target type is a generic interface implemented by 'List<T>':


            IReadOnlyList<int> a = [1, 2, 3];

Not supported yet in Roslyn Target type is 'IDictionary<TKey, TValue>' or 'IReadOnlyDictionary<TKey,TValue>'


            IDictionary<string, int> d = ["Yarik" : 26];

Not supported yet in Roslyn Target type is a type that implements 'IEnumerable<KeyValuePair<K, V>>' and has a valid indexer 'public V this[K key]'


            class MyDictionary<K, V> : IEnumerable<KeyValuePair<K, V>>
            {
              public IEnumerator<KeyValuePair<K, V>> GetEnumerator() => null;
              IEnumerator IEnumerable.GetEnumerator() => null;
              public V this[K key] { get { return default; } set { } }
            }
            ...
            MyDictionary<K, V> FromPair<K, V>(K k, V v) => [k:v];
            MyDictionary<K, V> FromExpression<K, V>(KeyValuePair<K, V> e) => [e];
            MyDictionary<K, V> FromSpread<K, V>(IEnumerable<KeyValuePair<K, V>> s) => [..s];

Kinds of collection expression elements.

Checks if a collection expression with a given element type can be lowered into RuntimeHelpers.CreateSpan<T>((RuntimeFieldHandle)...)

The following conditions must hold in order to use `RuntimeHelpers.CreateSpan()`: * non-empty * element type is allowed in blob wrapper () * all elements have constant values

Checks if access expression is really conditional: * IReferenceExpression - if 'a?.B' * IInvocationExpression - always false * IElementAccessExpression - if 'a?[b]' * IAssignmentExpression - always false

Reference qualifier, invoked expression, indexer operand or lhs of an assignment expression

Set conditional qualifier (without inserting parentheses for conditional access expressions).

Checks if expression has conditional access sign somewhere in the qualifier expressions. foo.Bar?.Baz().Qux | | |__|__|___ true |___|______________ false

Checks if expression is a top part of conditional access (with lifted type). foo?.Bar().Baz?[42].Qux |____|__|__|___|___ | __ false |___ true

Checks if expression is not top part of conditional access (with non-lifted type). foo?.Barr(a).Baz?[42].Qux | |___|___|___|___ | __ true |_____________________|___ false

Checks if you can apply conditional access expression to qualifier expression of some type.

Checks if whole expression type can be lifted after applying conditional access expression.

Checks if expression is a top part of conditional access expression: foo?.Bar().Baz?[42].Qux | | | | | |___ true |____|__|__|___|________ false

Gets qualifier expression of current conditional access expression: foo?.Bar().Baz?[42].Qux | | | | |____|___ foo?.Bar().Baz | |__|__|____________ foo |_______________________ null

Gets type of expression like it is standalone from conditional access chain: foo?.Value.ToString() | |__________ System.String |________________ System.Int32?

Checks if declaration has a block or expression body.

This method is not equal to '.GetCodeBody() != null', since it returns true if expression-bodied member/local functions has '=>' clause without expression

Get the containing method/constructor/operator/expression-bodied property or indexer/top-level code

Returns 'true' is this reference resolves into C#/COM indexed property mentioned in element access operand reference expression, returns 'false' in all otherwise cases (array indexers, custom indexers, etc)

Exposes common members of foreachable constructs (e.g. foreach statement, collection expression) for resolve purposes. This interface is NOT intended to be used in PSI features, please use pattern matching over C# tree node instead.

References range, 'foreach' keyword for foreach statement, '[' token for collection expressions.

Collection for iteration.

Gets the reference to 'GetEnumerator' method (or 'GetAsyncEnumerator' in an 'await foreach')

Gets the reference to 'GetEnumerator().MoveNext' method (or 'GetAsyncEnumerator().MoveNextAsync' in an 'await foreach')

Gets the reference to 'GetEnumerator().Current' property (or 'GetAsyncEnumerator().Current' in an 'await foreach')

Interpolated string results in a value of 'string' type. Translates to 'string.Format(...)' or optimized 'string.Concat' call.

If to get the 'string' instance the compiler uses 'DefaultInterpolatedStringHandler' type we return instead (to allow spans in holes).

Interpolated string results in a 'FormattableString' or 'IFormattable' value. Translates to 'FormattableStringFactory.Create(...)' call.

Interpolated string results in a value of the corresponding interpolated string handler type (type marked with [InterpolatedStringHandler] attribute). Translates to creation of corresponding interpolated string handler with subsequent 'AppendLiteral' and 'AppendFormatted' calls.

Returns refined range of the first literal part in the interpolated string expression.

Refined range does not include leading/trailing '$', '@', '{', '}' i.e. represents range of exactly textual part. Input: $"Abc {0}" Range: ^^^ Input: $"{0} Abc {1} Def" Range: ^^^^^

Returns count of inserts and literals.

$"a{0}" -> 2 $"a{0}b" -> 3 $"{0}{1}" -> 2

Returns 'true' is this reference resolves into method or local function directly mentioned in invoked reference expression, 'false' otherwise (for example, in a case of delegate variable invocation, this reference resolves into delegate type's Invoke() method)

For internal use on effectively partial declarations, i.e., on integral parts of actual .


            partial void AfterCommit();     // IsPartial=true,  IsPartialDefinition=true
            partial void AfterCommit() { }  // IsPartial=true,  IsPartialDefinition=false
            extern void AfterCommit();      // IsPartial=false, IsPartialDefinition=false
            public void AfterCommit() { }   // IsPartial=false, IsPartialDefinition=false

true if this declaration is the definition part (part without the executable body), false if this declaration is either the implementation part or is false.

Checks pattern to be `not null`

Primary constructor parameters are not available for use - in static members and static closures - in attributes - in constant contexts Primary constructor parameters are available for use in instance member body. The use will capture the primary parameter into type's state Primary constructor parameters are available for use to initialize the instance fields/properties or to invoke the base constructor. Primary constructor parameters are available to reference in documentation Check for semi-auto property with exactly one accessor implemented, e.g.:


            int Prop { get => field ?? 0; set; }
            int Prop { get; set => field ??= value; }
            int Prop { get; set => IgnorePropUpdate(value); }

Ignores the language version.

Declarations of ITypeElements that are not type parameters

'inclusiveStartIndex..'

'..exclusiveEndIndex'

'inclusiveStartIndex..exclusiveEndIndex'

'..'

Returns kind of extension member usage or value .

Returns true if a classic extension method was invoked in extension form (but not as a static method).

Materializes inferred name of tuple item or anonymous object field. Doesn't materialize tuple component name if it isn't inferred one. Materializes inferred name of tuple item or anonymous object field. If no name is inferred for tuple component name, materializes default component name.

Checks reference expression to be in a form of 'someName'

Checks reference expression to be in a form of 'expectedText'

Checks reference expression to be in a form of 'Some.Simple.Names'

Checks reference expression to be in a form of 'global::Some.Simple{T}.Names'

x is { ThisOne.OrThisOne: pat }

x is { Qualifier.ThisOne: pat }

x is { ThisOne.OrThisOne }

Returns `Foo` reference for `x is { Foo: 42 }` pattern Returns `null` reference for `x is { Foo.Bar: 42 }` pattern

Returns `Foo` reference expression for `x is { Foo.Bar: 42 }` pattern

Returns `Foo` reference for `x is { Foo.Bar: 42 }` pattern

Returns `Bar` reference for `x is { Foo.Bar: 42 }` pattern

A reference to 'GetPinnableReference' method. See https://github.com/dotnet/csharplang/blob/master/proposals/csharp-7.3/pattern-based-fixed.md

case: * For 'string s' in 'M(out string s)' returns 'string'; * For 'var (a, b)' in 'var (a, b) = 42;' returns 'int';

No need to push level here, already moved to +4

Translate local tree text range (inside DocCRefExpression) to comment text range (inside containing comment)

Translate local tree text range (inside DocCRefExpression) to file tree text range (inside containing comment's file)

Special argument info implementation for arguments of interpolated string handler constructor.

Special argument info for passing to trailing 'out bool shouldAppend' parameter of the interpolated string handler constructor.

Returns symbol table for code completion

According to C# specs 14.12 • If A is not a nullable type or a reference type, a compile-time error occurs. • If A is a nullable type and an implicit conversion exists from b to A0, the result type is A0. At run-time, a is first evaluated. If a is not null, a is unwrapped to type A0, and this becomes the result. Otherwise, b is evaluated and converted to type A0, and this becomes the result. • Otherwise, if an implicit conversion exists from b to A, the result type is A. At run-time, a is first evaluated. If a is not null, a becomes the result. Otherwise, b is evaluated and converted to type A, and this becomes the result. • Otherwise, if an implicit conversion exists from A0 to B, the result type is B. At run-time, a is first evaluated. If a is not null, a is unwrapped to type A0 (unless A and A0 are the same type) and converted to type B, and this becomes the result. Otherwise, b is evaluated and becomes the result. • Otherwise, a and b are incompatible, and a compile-time error occurs.

For some features (e.g. UsageAnalyzer and Navigation) it is better to have rather than multiple , but at the same time, we want to have relevant collection for reporting purposes. So let's store both and chose as a candidate with the highest accessibility.

Indicates whether an owner node has all syntactic elements required for resolve; In case it is 'false' reference is considered ignorable. 'await Task' => true 'await _missing_' => false 'await foreach (var x in xs)' => true 'await foreach (var x' => false

Unescaped text (no xml entities & etc)

Builds the qualified string to access the given target from our reference point

Breaking change in NET 10: partial members of interfaces were non-virtual, only partial methods still are now. See https://github.com/dotnet/roslyn/blob/3a421537e223/docs/compilers/CSharp/Compiler%20Breaking%20Changes%20-%20DotNet%2010.md Syntax-based, must not use resolve.

Used to determine the position of the group relative to other groups.

Removes only regions that looks as if they were produced by reordering process (to avoid duplicating them).

Removes every region except generated.

Removes all regions.

Format code during WritePSI action

record

file, required

scoped in lambda parameters, '[with()]'

Denotes to expression state at specified point

Check if given expression is eligible for comparison

State of the single node in the control flow graph

Shared between all instances of context

State for each variable from

The set af possible memory states at this point Is null if the number of states greater than threshold, and thus the cyclomatic complexity of the code is too large

Indicates that at all paths to this point there was recursive call

If total number of states on all graph edges exceeded this number, then raise context overflow

Removes specified function from all prerequierements and returns the set of functions which prerequirements are now completely safisfied Keeps track of transitive conversion to a delayed delegate

Try to recognize invocation of special methods, and patch context accordingly

Check if possible NRE should be checked if jump by

Variable state is completely unknown

Value for container-like variables (collections, Lazy{T}, Task{T}), should be composed with UNKNOWN/NULL/NOT_NULL flags which means values for elements of the container

Special value for unchecked variables indicating that value is unknown and possible NRE shouldn't be reported

Special value for unchecked variables indicating that value is though known to be non NULL

Special value for unchecked variables indicating that value is unknown, but though can be null

Only use for presentation. Do not for caching or hash table keys.

true if any serializable decorations are found

There methods are supported in LINQ to Entities

Overloads which do not accept positional arguments are supported in LINQ to Entities

Overloads which do not accept IComparer are supported in LINQ to Entities

Overloads which do not accept IEqualityComparer are supported in LINQ to Entities

All overloads seem to be supported in LINQ to Entities (contradicts documentation)

Whether this method can be run on both client and server side without throwing exceptions Whether current should stop at this method Whether the invocation expression could be related to the DbContext configuration

Stays null until types are resolved for the first time

Whether resolve status of any super types changed

Creates initial context

Merges local contexts without copying.

Creates deep or shallow clone

Returns true if this expression can potentially have an issue. Returns true if any relevant inclusions are found

Creates initial context

Creates deep or shallow clone

Returns true if typeOwner contains information about some chain.

Entity Framework element's validity regarding file changes on its parts (isn't affected by resolve status)

Identical to Microsoft.EntityFrameworkCore.QueryTrackingBehavior

1 if is of higher priority than , -1 if if of higher priority than , 0 otherwise.

Key is the substitution-less string representation of the entity's

Key is the ID of Target entity for each navigation

Key is the ID of base element

TypeElement to check if it can be a DbContext descendant Base DbContext type to check against Entity Framework version File with DbContext object usage Dependency Store for SWA Set of which are known to be valid DbContexts DbContext if found and analyzed successfully

Call this method to update a specific Entity Framework model with any changes which occurred after the previous update if necessary.

Returns false if model could not be updated File containing cached elements FQN : [list of cached elements]

You must ensure that cache is up-to-date for if is set to false.

You must ensure that cache is up-to-date for DbContext if is set to false.

You must ensure that cache is up-to-date for DbContexts if is set to false.

Must be called under write lock

Must be called under WriteLock

Must be called under write lock

Must be called under write lock.

ID of the invalidated element.

Must be called under write lock

ID of the removed element True if this method is called recursively Whether the element was successfully removed Do not use this directly, instead use

Set of DbFunctions declared with FluentAPI only!

Values lower than -1 are not allowed

Entity Framework Core only

Entity Framework only

Entity Framework Core only

Entity Framework only

Returns original type if it is not a type parameter type. Returns resolved type if substitution is resolved successfully. Returns null otherwise.

Use this method to get DbContexts from descendants and update and if DbContexts are found.

Specifies whether this relation should be ignored during Entity Framework query analysis.

Specifies whether this relation will be replicated in the query and cannot lead to problems like N+1.

"Accounts" in context.People.SelectMany(p => p.Accounts)

Specifies whether this relation can be automatically included based on FluentAPI configuration. Whether or not this relation will actually be included is dependent on other information as well.

Inspector will switch to optimistic mode for the current block of code after encountering complexity overflow.

Can be an entity type or DbContext type

Potential navigational property

DbContext which contains the navigation

Property type member

Specifies whether this relation should be ignored during Entity Framework query analysis.

Value of -1 signifies maximum allowed or unlimited length.

Start new chain from scratch

Creates chain from another considering the original variable

Creates deep or shallow clone

Start chain with DbContext Configuration

Builder of the control flow initial state (i.t. the context of the graph entry point)

Sorted set of disjoint LongIntervals

Set of the possible memory snapshots This class is immutable! (i.e. any modification makes new copy of the class)

note: 'optimistic' - do not inject 'null' state if variable is weak

Annotated resolve context that relies on expression types and re-inferred substitutions from the nullable inspector. Must be used ONLY for post-analysis where all other references are processed and have their final state. If used to re-infer a type during the analysis itself, it might observe stale in related references from previous analysis passes. E.g. 'Infer(new(), arg)' - since the type of 'new()' depends on the arguments above it, we can't properly infer it until the analysis is finished. Use AnnotatedTargetTypeExpressionResolveContext for this case and ensure that it's called when all expressions affecting the type are processed.

This resolve context is used to calculate target-typed expressions while the analysis is still in progress, and forces re-calculation of all expression types for expressions not yet cached in nullable analysis, as well as force update of precalculated resolve results for all references. It must be called after processing all parent expressions that might affect the target-typed expression type.

If you are using this inspector from PostValueAnalysis try switching to which will save some calculations by deferring to CachedExpressionType and PrecalculatedData whenever possible.

Locals are given slots when their declarations are encountered. We only need give slots to local variables, out parameters, and the "this" variable of a struct constructs. Other variables are not given slots, and are therefore not tracked by the analysis. This returns -1 for a variable that is not tracked, for fields of structs that have the same assigned status as the container, and for structs that (recursively) contain no data members. We do not need to track references to variables that occur before the variable is declared, as those are reported in an earlier phase as "use before declaration". That allows us to avoid giving slots to local variables before processing their declarations.

will be required if Roslyn team will refuse to fix this: https://github.com/dotnet/roslyn/issues/47892

Default RValue state of the current variable e.g. when the variable encountered for the first time without any prior checks or assignments

The result of GetValueNullableAnnotation() on this variable's type with 'DefaultRValueAnnotation' nullability

'this' struct variable info for instance struct ctor

Get number of variables in index

Add new variable into index

Add type to registered types index

Get the index of the given type, or -1 if type is not registered

Get the total number of registered types

Check if history check point is associated with given element, and returns it

Enumerate history check points which runs out of scope when control flow moves from to

Find info by declared element - only for top-level elements

Finds variable by its and its parents' declared elements. Returned info may have different state e.g. AccessStateIndex

Search for unchecked infos, where given expr is found in qualifier (cache results)

Search for unchecked infos, where given local variable or parameter is found in qualifier (cache results)

Find info by expression - look into unchecked variables, and into fields of managed variable (cache results)

According to C# specs 22.1, function body block is iterator if it contains one or more 'yield' statements. This method do not expands chameleon nodes if possible.

Get the required extern alias

null if module is not referenced, String.Empty for no alias (i.e. == global)

Get the possible extern aliases list

null if module is not referenced, String.Empty for no alias (i.e. == global)

Try to replaced qualified reference by any existing alias

Try to extract the qualifier reference of the given reference' element i.e. extract reference to B from reference to C in expression A.B.C

null if reference could not be extracted

Reference to component name in WinForm generated code

Performs binding of type usage node to a specified type. Binding result isn't guaranteed to be a type usage (e.g. containing object creation expression can be converted into a tuple expression).

Binds symbol alias reference to the specified aliased type.

Translates changes in generated code-behind file to original file (Razor, ASP, etc). If strict, HTML whitespace statements on bounds are not included. Use for single added statement to be returned.

Scalar indexer by 'System.Index' type, e.g. 'array[^1]'

Slice indexer by 'System.Range' type, e.g. 'array[0..5]'

Represents a global symbol alias stored in a . Does not itself implement APIs like . Each global has created via method.

Represents an instance of a global using alias. Uses a to implement and other specific members. Uses a to get declarations. Uses for equality with an underlying .

Represents a method symbol corresponding to a method declaration inside an extension declaration.

Containing type is a type extension. Doesn't include parameters and type parameters from containing type extension. Exposes .

Represents a method symbol generated for a containing class from a method declaration inside an extension declaration.

Represents a sign operator symbol corresponding to an operator declaration inside an extension declaration.

Containing type is a type extension. Doesn't include parameters and type parameters from containing type extension. Exposes .

Represents a method symbol generated for a containing class from an operator declaration inside an extension declaration.

Recursion-preventing guard flag

Tries to find the type parameter of the inherited method. According to C# specs 25.6.2

Base class for method symbols generated for a containing class from an extension member.

* Containing type is a containing class of a containing type extension * Static * Includes receiver parameter in case the declaration is non-static * Includes type parameters from containing type extension

Base class for method symbols generated for a containing class from an extension member.

Performs search of default constructors implicitly used in collection expressions.

Subscribes to .editorconfig changes and invalidates the following cached PSI file data: * *

.editorconfig can contain "generated_code" property which affects NRT analysis.

Provides implicit conversions found inside a tree node

Root node from which searching is started Indicates whether searching should process only user defined conversions Indicates whether inner nodes should be processed recursively

Provides base implementation for searching of implicitly used constructors.

Represents information about a conversion and about the place where it has been found.

Performs search of members referenced in collection expression and its elements.

When a modifiers order in settings is incomplete or invalid, we need to complete it with missing items and remove the wrong one. Doing so every time is expensive. So we need to cache the results. This is what this component does.

Determines explicitly defined access rights in modifiers list. Ensures there is no access modifier conflicts and each access modifier is mentioned once.

Use when needs to detect broken/uncompleted code. A collection of modifiers. The calculated syntactically defined access rights if specified correctly or undefined at all; otherwise, null.

Extract single declaration from multiple declaration node, if necessary. All declarations are not invalidated

Split the multiple declaration list so that given member will be the first declaration in the list. All declarations are not invalidated

Split the multiple declaration list so that given member will be the last declaration in the list. All declarations are not invalidated

Delete the given member declaration from the multiple declaration If the member is the single in the multiple node, then delete whole multiple node

Check if we can omit parentheses in situations like '1 + (2 + 3)' or '"aa" + ("bb" + "cc")' when we can proof binary operator is associative.

ReSharper's own language level. Is used to override auto-detected project language level.

This enum differs from : * has member meaning language level is not overridden in ReSharper settings

Gets symbols for the specified using alias directive.

If alias reference to a namespace or a regular declared type then symbol table should include not only symbol for a symbol alias itself but also a symbol for the aliased type or namespace, because such aliases are transparent and their usages are resolved directly to the aliased namespace or type.

When using COM interop type members with "Embed Interop Types" property, return values of methods, properties and indexers are 'dynamic' instead of 'object'

Prefers enum member in enum initializer

Special filter for DotPeek. Disambiguate between event and it's private backing field

Excludes extension receiver parameter from disallowed contexts.

Extension receiver parameter is accessible in non-static extension members and as a 'nameof()' argument in any member.

Implements preference of instance properties over extension properties.

If there are methods and non-method symbols, it leaves only methods.

'Finalize' is allowed in certain contexts e.g. 'nameof(Finalize)'

C# 4: properties with parameters (but not default property!) from COM-types could be accessed

C# 14: type extension members can be accessed through a qualifier

Filter local variable declarations by their position in the tree

Workaround for compiler bug existed in C# 3.0. See https://connect.microsoft.com/VisualStudio/feedback/details/328765/cannot-invoke-extension-method-named-length-on-an-array

Modification service performing binding of unresolved type usages refering to a type alias.

C# 2.0 spec 13.1.4

Find custom implicit operator according to paragraph 6.4.3

Get the corresponding using directive (if any) which is used to import references' target

Builds the list of conflicts which will occur if the given namespace is imported into the given scope. References with existing value in UserData by the given key will not be included

Autogenerated identifier classes and identifier objects to Themed Icons registered with . Identifier classes should be used in attributes, XAML, or generic parameters. Where an value is expected, use the identifier object in the Id field of the identifier class.

This code was compile-time generated to support Themed Icons in the JetBrains application. It has two primary goals: load the icons of this assembly to be registered with so that they were WPF-accessible and theme-sensitive; and emit early-bound accessors for referencing icons in codebehind in a compile-time-validated manner.

XAML

For performance reasons, the icons are not individually exposed with application resources. There is a custom markup extension to bind an image source in markup. To use an icon from XAML, set an property to the markup extension, which takes an icon identifier class (nested in class) as a parameter. Example: <Image Source="{icons:ThemedIcon myres:PsiCSharpThemedIcons+Trinity}" />

Attributes

Sometimes you have to reference an icon from a type attriute when you're defining objects in code. Typical examples are Options pages and Tool Windows. To avoid the use of string IDs which are not validated very well, we've emitted identifier classes to be used with typeof() expression, one per each icon. Use the attribute overload which takes a for an image, and choose your icon class from nested classes in the class. Example: [Item(Name="Sample", Icon=typeof(PsiCSharpThemedIcons.Trinity))]

CodeBehind

In codebehind, we have two distinct tasks: (a) specify some icon in the APIs and (b) render icon images onscreen. On the APIs stage you should only manipulate icon identifier objects (of type , statically defined in in Id fields). Icon identifier classes (nested in ) should be turned into icon identifier objects as early as possible. Rendering is about getting an to assign to WPF, or to use with GDI+ / Windows Forms. You should turn an identifier object into a rendered image as late as possible. The identifier is static and lightweight and does not depend on the current theme, while the image is themed and has to be loaded or generated/rasterized. You need an instance to get the image out of an icon identifier object. Once you got the image, you should take care to change it with theme changes — either by using a live image property, or by listening to the theme change event. See and its extensions for the related facilities. Example:

// Getting IconId identifier object to use with APIs
            IconId iconid = PsiCSharpThemedIcons.Trinity.Id;

// Getting IconId out of an Icon Identifier Class type
            IconId iconid = new JetBrains.Application.Icons.CompiledIconsCs.CompiledIconCsId(typeof(PsiCSharpThemedIcons.Trinity));

// Getting image for screen rendering by IconId
            themediconmanager.Icons[icnoid]

// Getting image for screen rendering by Icon Identifier Class
            themediconmanager.GetIcon<PsiCSharpThemedIcons.Trinity>()

Icons Origin

This code was generated by a pre-compile build task from a set of input files which are XAML files adhering to a certain convention, as convenient for exporting them from the Illustrator workspace, plus separate PNG files with raster icons. In the projects, these files are designated with ThemedIconsXamlV3 and ThemedIconPng build actions and do not themselves get into the output assembly. All of such files are processed, vector images for different themes of the same icon are split and combined into the single list of icons in this assembly. This list is then written into the genearted XAML file (compiled into BAML within assembly), and serves as the source for this generated code.

Csharp Themed Icon generated identifiers: — identifier class, for use in attributes, XAML, and generic parameters; — identifier object, as a field in the identifier class, for use where an value is expected.


                                             
                 33333333333333I/`           
                 uu''''''''''''^su/`         
                 oo--------------~Jo*`       
                 55----        ----~l2+`     
                 aa----        ------~ta+    
                 SS----            ----SS    
                 kk----            ----kk    
                 kk----            ----kk    
              `!xOmmmmmmmmmmmmmmm  ----PP    
             -Ek!_```bbbb``bb``bbbb----UU    
             }6,`^26666``````````66----66    
             EE``1EEEEEEE``EE``EEEE----99    
             Jy_.=eyyyy..........yy----ww    
             _Il~_---oooo--oo--oooobbbbbb    
              `;7x111111111111111

For details on Themed Icons and their use, see Remarks on the outer class. <Image Source="{icons:ThemedIcon myres:PsiCSharpThemedIcons+Csharp}" />  [Item(Name="Sample", Icon=typeof(PsiCSharpThemedIcons.Csharp))] // C# Type attribute IconId iconid = PsiCSharpThemedIcons.Csharp.Id; // IconId identifier object themediconmanager.GetIcon<PsiCSharpThemedIcons.Csharp>() // Icon image for rendering


                                             
                 33333333333333I/`           
                 uu''''''''''''^su/`         
                 oo--------------~Jo*`       
                 55----        ----~l2+`     
                 aa----        ------~ta+    
                 SS----            ----SS    
                 kk----            ----kk    
                 kk----            ----kk    
              `!xOmmmmmmmmmmmmmmm  ----PP    
             -Ek!_```bbbb``bb``bbbb----UU    
             }6,`^26666``````````66----66    
             EE``1EEEEEEE``EE``EEEE----99    
             Jy_.=eyyyy..........yy----ww    
             _Il~_---oooo--oo--oooobbbbbb    
              `;7x111111111111111


                                             
                 33333333333333I/`           
                 uu''''''''''''^su/`         
                 oo--------------~Jo*`       
                 55----        ----~l2+`     
                 aa----        ------~ta+    
                 SS----            ----SS    
                 kk----            ----kk    
                 kk----            ----kk    
              `!xOmmmmmmmmmmmmmmm  ----PP    
             -Ek!_```bbbb``bb``bbbb----UU    
             }6,`^26666``````````66----66    
             EE``1EEEEEEE``EE``EEEE----99    
             Jy_.=eyyyy..........yy----ww    
             _Il~_---oooo--oo--oooobbbbbb    
              `;7x111111111111111


                                             
                 33333333333333I/`           
                 uu''''''''''''^su/`         
                 oo--------------~Jo*`       
                 55----        ----~l2+`     
                 aa----        ------~ta+    
                 SS----            ----SS    
                 kk----            ----kk    
                 kk----            ----kk    
              `!xOmmmmmmmmmmmmmmm  ----PP    
             -Ek!_```bbbb``bb``bbbb----UU    
             }6,`^26666``````````66----66    
             EE``1EEEEEEE``EE``EEEE----99    
             Jy_.=eyyyy..........yy----ww    
             _Il~_---oooo--oo--oooobbbbbb    
              `;7x111111111111111


                                             
                 33333333333333I/`           
                 uu''''''''''''^su/`         
                 oo--------------~Jo*`       
                 55----        ----~l2+`     
                 aa----        ------~ta+    
                 SS----            ----SS    
                 kk----            ----kk    
                 kk----            ----kk    
              `!xOmmmmmmmmmmmmmmm  ----PP    
             -Ek!_```bbbb``bb``bbbb----UU    
             }6,`^26666``````````66----66    
             EE``1EEEEEEE``EE``EEEE----99    
             Jy_.=eyyyy..........yy----ww    
             _Il~_---oooo--oo--oooobbbbbb    
              `;7x111111111111111


                                             
                 33333333333333I/`           
                 uu''''''''''''^su/`         
                 oo--------------~Jo*`       
                 55----        ----~l2+`     
                 aa----        ------~ta+    
                 SS----            ----SS    
                 kk----            ----kk    
                 kk----            ----kk    
              `!xOmmmmmmmmmmmmmmm  ----PP    
             -Ek!_```bbbb``bb``bbbb----UU    
             }6,`^26666``````````66----66    
             EE``1EEEEEEE``EE``EEEE----99    
             Jy_.=eyyyy..........yy----ww    
             _Il~_---oooo--oo--oooobbbbbb    
              `;7x111111111111111


                                             
                 33333333333333I/`           
                 uu''''''''''''^su/`         
                 oo--------------~Jo*`       
                 55----        ----~l2+`     
                 aa----        ------~ta+    
                 SS----            ----SS    
                 kk----            ----kk    
                 kk----            ----kk    
              `!xOmmmmmmmmmmmmmmm  ----PP    
             -Ek!_```bbbb``bb``bbbb----UU    
             }6,`^26666``````````66----66    
             EE``1EEEEEEE``EE``EEEE----99    
             Jy_.=eyyyy..........yy----ww    
             _Il~_---oooo--oo--oooobbbbbb    
              `;7x111111111111111


                                             
                 33333333333333I/`           
                 uu''''''''''''^su/`         
                 oo--------------~Jo*`       
                 55----        ----~l2+`     
                 aa----        ------~ta+    
                 SS----            ----SS    
                 kk----            ----kk    
                 kk----            ----kk    
              `!xOmmmmmmmmmmmmmmm  ----PP    
             -Ek!_```bbbb``bb``bbbb----UU    
             }6,`^26666``````````66----66    
             EE``1EEEEEEE``EE``EEEE----99    
             Jy_.=eyyyy..........yy----ww    
             _Il~_---oooo--oo--oooobbbbbb    
              `;7x111111111111111


                                             
                 33333333333333I/`           
                 uu''''''''''''^su/`         
                 oo--------------~Jo*`       
                 55----        ----~l2+`     
                 aa----        ------~ta+    
                 SS----            ----SS    
                 kk----            ----kk    
                 kk----            ----kk    
              `!xOmmmmmmmmmmmmmmm  ----PP    
             -Ek!_```bbbb``bb``bbbb----UU    
             }6,`^26666``````````66----66    
             EE``1EEEEEEE``EE``EEEE----99    
             Jy_.=eyyyy..........yy----ww    
             _Il~_---oooo--oo--oooobbbbbb    
              `;7x111111111111111


                                             
                 33333333333333I/`           
                 uu''''''''''''^su/`         
                 oo--------------~Jo*`       
                 55----        ----~l2+`     
                 aa----        ------~ta+    
                 SS----            ----SS    
                 kk----            ----kk    
                 kk----            ----kk    
              `!xOmmmmmmmmmmmmmmm  ----PP    
             -Ek!_```bbbb``bb``bbbb----UU    
             }6,`^26666``````````66----66    
             EE``1EEEEEEE``EE``EEEE----99    
             Jy_.=eyyyy..........yy----ww    
             _Il~_---oooo--oo--oooobbbbbb    
              `;7x111111111111111


                                             
                 33333333333333I/`           
                 uu''''''''''''^su/`         
                 oo--------------~Jo*`       
                 55----        ----~l2+`     
                 aa----        ------~ta+    
                 SS----            ----SS    
                 kk----            ----kk    
                 kk----            ----kk    
              `!xOmmmmmmmmmmmmmmm  ----PP    
             -Ek!_```bbbb``bb``bbbb----UU    
             }6,`^26666``````````66----66    
             EE``1EEEEEEE``EE``EEEE----99    
             Jy_.=eyyyy..........yy----ww    
             _Il~_---oooo--oo--oooobbbbbb    
              `;7x111111111111111


                                             
                 33333333333333I/`           
                 uu''''''''''''^su/`         
                 oo--------------~Jo*`       
                 55----        ----~l2+`     
                 aa----        ------~ta+    
                 SS----            ----SS    
                 kk----            ----kk    
                 kk----            ----kk    
              `!xOmmmmmmmmmmmmmmm  ----PP    
             -Ek!_```bbbb``bb``bbbb----UU    
             }6,`^26666``````````66----66    
             EE``1EEEEEEE``EE``EEEE----99    
             Jy_.=eyyyy..........yy----ww    
             _Il~_---oooo--oo--oooobbbbbb    
              `;7x111111111111111


                                             
                 33333333333333I/`           
                 uu''''''''''''^su/`         
                 oo--------------~Jo*`       
                 55----        ----~l2+`     
                 aa----        ------~ta+    
                 SS----            ----SS    
                 kk----            ----kk    
                 kk----            ----kk    
              `!xOmmmmmmmmmmmmmmm  ----PP    
             -Ek!_```bbbb``bb``bbbb----UU    
             }6,`^26666``````````66----66    
             EE``1EEEEEEE``EE``EEEE----99    
             Jy_.=eyyyy..........yy----ww    
             _Il~_---oooo--oo--oooobbbbbb    
              `;7x111111111111111


                                             
                 33333333333333I/`           
                 uu''''''''''''^su/`         
                 oo--------------~Jo*`       
                 55----        ----~l2+`     
                 aa----        ------~ta+    
                 SS----            ----SS    
                 kk----            ----kk    
                 kk----            ----kk    
              `!xOmmmmmmmmmmmmmmm  ----PP    
             -Ek!_```bbbb``bb``bbbb----UU    
             }6,`^26666``````````66----66    
             EE``1EEEEEEE``EE``EEEE----99    
             Jy_.=eyyyy..........yy----ww    
             _Il~_---oooo--oo--oooobbbbbb    
              `;7x111111111111111


                                             
                 33333333333333I/`           
                 uu''''''''''''^su/`         
                 oo--------------~Jo*`       
                 55----        ----~l2+`     
                 aa----        ------~ta+    
                 SS----            ----SS    
                 kk----            ----kk    
                 kk----            ----kk    
              `!xOmmmmmmmmmmmmmmm  ----PP    
             -Ek!_```bbbb``bb``bbbb----UU    
             }6,`^26666``````````66----66    
             EE``1EEEEEEE``EE``EEEE----99    
             Jy_.=eyyyy..........yy----ww    
             _Il~_---oooo--oo--oooobbbbbb    
              `;7x111111111111111


                                             
                 33333333333333I/`           
                 uu''''''''''''^su/`         
                 oo--------------~Jo*`       
                 55----        ----~l2+`     
                 aa----        ------~ta+    
                 SS----            ----SS    
                 kk----            ----kk    
                 kk----            ----kk    
              `!xOmmmmmmmmmmmmmmm  ----PP    
             -Ek!_```bbbb``bb``bbbb----UU    
             }6,`^26666``````````66----66    
             EE``1EEEEEEE``EE``EEEE----99    
             Jy_.=eyyyy..........yy----ww    
             _Il~_---oooo--oo--oooobbbbbb    
              `;7x111111111111111


                                             
                 33333333333333I/`           
                 uu''''''''''''^su/`         
                 oo--------------~Jo*`       
                 55----        ----~l2+`     
                 aa----        ------~ta+    
                 SS----            ----SS    
                 kk----            ----kk    
                 kk----            ----kk    
              `!xOmmmmmmmmmmmmmmm  ----PP    
             -Ek!_```bbbb``bb``bbbb----UU    
             }6,`^26666``````````66----66    
             EE``1EEEEEEE``EE``EEEE----99    
             Jy_.=eyyyy..........yy----ww    
             _Il~_---oooo--oo--oooobbbbbb    
              `;7x111111111111111


                                             
                 33333333333333I/`           
                 uu''''''''''''^su/`         
                 oo--------------~Jo*`       
                 55----        ----~l2+`     
                 aa----        ------~ta+    
                 SS----            ----SS    
                 kk----            ----kk    
                 kk----            ----kk    
              `!xOmmmmmmmmmmmmmmm  ----PP    
             -Ek!_```bbbb``bb``bbbb----UU    
             }6,`^26666``````````66----66    
             EE``1EEEEEEE``EE``EEEE----99    
             Jy_.=eyyyy..........yy----ww    
             _Il~_---oooo--oo--oooobbbbbb    
              `;7x111111111111111


                                             
                 33333333333333I/`           
                 uu''''''''''''^su/`         
                 oo--------------~Jo*`       
                 55----        ----~l2+`     
                 aa----        ------~ta+    
                 SS----            ----SS    
                 kk----            ----kk    
                 kk----            ----kk    
              `!xOmmmmmmmmmmmmmmm  ----PP    
             -Ek!_```bbbb``bb``bbbb----UU    
             }6,`^26666``````````66----66    
             EE``1EEEEEEE``EE``EEEE----99    
             Jy_.=eyyyy..........yy----ww    
             _Il~_---oooo--oo--oooobbbbbb    
              `;7x111111111111111


                                             
                 33333333333333I/`           
                 uu''''''''''''^su/`         
                 oo--------------~Jo*`       
                 55----        ----~l2+`     
                 aa----        ------~ta+    
                 SS----            ----SS    
                 kk----            ----kk    
                 kk----            ----kk    
              `!xOmmmmmmmmmmmmmmm  ----PP    
             -Ek!_```bbbb``bb``bbbb----UU    
             }6,`^26666``````````66----66    
             EE``1EEEEEEE``EE``EEEE----99    
             Jy_.=eyyyy..........yy----ww    
             _Il~_---oooo--oo--oooobbbbbb    
              `;7x111111111111111


                                             
                 33333333333333I/`           
                 uu''''''''''''^su/`         
                 oo--------------~Jo*`       
                 55----        ----~l2+`     
                 aa----        ------~ta+    
                 SS----            ----SS    
                 kk----            ----kk    
                 kk----            ----kk    
              `!xOmmmmmmmmmmmmmmm  ----PP    
             -Ek!_```bbbb``bb``bbbb----UU    
             }6,`^26666``````````66----66    
             EE``1EEEEEEE``EE``EEEE----99    
             Jy_.=eyyyy..........yy----ww    
             _Il~_---oooo--oo--oooobbbbbb    
              `;7x111111111111111


                                             
                 33333333333333I/`           
                 uu''''''''''''^su/`         
                 oo--------------~Jo*`       
                 55----        ----~l2+`     
                 aa----        ------~ta+    
                 SS----            ----SS    
                 kk----            ----kk    
                 kk----            ----kk    
              `!xOmmmmmmmmmmmmmmm  ----PP    
             -Ek!_```bbbb``bb``bbbb----UU    
             }6,`^26666``````````66----66    
             EE``1EEEEEEE``EE``EEEE----99    
             Jy_.=eyyyy..........yy----ww    
             _Il~_---oooo--oo--oooobbbbbb    
              `;7x111111111111111


                                             
                 33333333333333I/`           
                 uu''''''''''''^su/`         
                 oo--------------~Jo*`       
                 55----        ----~l2+`     
                 aa----        ------~ta+    
                 SS----            ----SS    
                 kk----            ----kk    
                 kk----            ----kk    
              `!xOmmmmmmmmmmmmmmm  ----PP    
             -Ek!_```bbbb``bb``bbbb----UU    
             }6,`^26666``````````66----66    
             EE``1EEEEEEE``EE``EEEE----99    
             Jy_.=eyyyy..........yy----ww    
             _Il~_---oooo--oo--oooobbbbbb    
              `;7x111111111111111


                                             
                 33333333333333I/`           
                 uu''''''''''''^su/`         
                 oo--------------~Jo*`       
                 55----        ----~l2+`     
                 aa----        ------~ta+    
                 SS----            ----SS    
                 kk----            ----kk    
                 kk----            ----kk    
              `!xOmmmmmmmmmmmmmmm  ----PP    
             -Ek!_```bbbb``bb``bbbb----UU    
             }6,`^26666``````````66----66    
             EE``1EEEEEEE``EE``EEEE----99    
             Jy_.=eyyyy..........yy----ww    
             _Il~_---oooo--oo--oooobbbbbb    
              `;7x111111111111111


                                             
                 33333333333333I/`           
                 uu''''''''''''^su/`         
                 oo--------------~Jo*`       
                 55----        ----~l2+`     
                 aa----        ------~ta+    
                 SS----            ----SS    
                 kk----            ----kk    
                 kk----            ----kk    
              `!xOmmmmmmmmmmmmmmm  ----PP    
             -Ek!_```bbbb``bb``bbbb----UU    
             }6,`^26666``````````66----66    
             EE``1EEEEEEE``EE``EEEE----99    
             Jy_.=eyyyy..........yy----ww    
             _Il~_---oooo--oo--oooobbbbbb    
              `;7x111111111111111


                                             
                 33333333333333I/`           
                 uu''''''''''''^su/`         
                 oo--------------~Jo*`       
                 55----        ----~l2+`     
                 aa----        ------~ta+    
                 SS----            ----SS    
                 kk----            ----kk    
                 kk----            ----kk    
              `!xOmmmmmmmmmmmmmmm  ----PP    
             -Ek!_```bbbb``bb``bbbb----UU    
             }6,`^26666``````````66----66    
             EE``1EEEEEEE``EE``EEEE----99    
             Jy_.=eyyyy..........yy----ww    
             _Il~_---oooo--oo--oooobbbbbb    
              `;7x111111111111111


                                             
                 33333333333333I/`           
                 uu''''''''''''^su/`         
                 oo--------------~Jo*`       
                 55----        ----~l2+`     
                 aa----        ------~ta+    
                 SS----            ----SS    
                 kk----            ----kk    
                 kk----            ----kk    
              `!xOmmmmmmmmmmmmmmm  ----PP    
             -Ek!_```bbbb``bb``bbbb----UU    
             }6,`^26666``````````66----66    
             EE``1EEEEEEE``EE``EEEE----99    
             Jy_.=eyyyy..........yy----ww    
             _Il~_---oooo--oo--oooobbbbbb    
              `;7x111111111111111


                                             
                 33333333333333I/`           
                 uu''''''''''''^su/`         
                 oo--------------~Jo*`       
                 55----        ----~l2+`     
                 aa----        ------~ta+    
                 SS----            ----SS    
                 kk----            ----kk    
                 kk----            ----kk    
              `!xOmmmmmmmmmmmmmmm  ----PP    
             -Ek!_```bbbb``bb``bbbb----UU    
             }6,`^26666``````````66----66    
             EE``1EEEEEEE``EE``EEEE----99    
             Jy_.=eyyyy..........yy----ww    
             _Il~_---oooo--oo--oooobbbbbb    
              `;7x111111111111111


                                             
                 33333333333333I/`           
                 uu''''''''''''^su/`         
                 oo--------------~Jo*`       
                 55----        ----~l2+`     
                 aa----        ------~ta+    
                 SS----            ----SS    
                 kk----            ----kk    
                 kk----            ----kk    
              `!xOmmmmmmmmmmmmmmm  ----PP    
             -Ek!_```bbbb``bb``bbbb----UU    
             }6,`^26666``````````66----66    
             EE``1EEEEEEE``EE``EEEE----99    
             Jy_.=eyyyy..........yy----ww    
             _Il~_---oooo--oo--oooobbbbbb    
              `;7x111111111111111


                                             
                 33333333333333I/`           
                 uu''''''''''''^su/`         
                 oo--------------~Jo*`       
                 55----        ----~l2+`     
                 aa----        ------~ta+    
                 SS----            ----SS    
                 kk----            ----kk    
                 kk----            ----kk    
              `!xOmmmmmmmmmmmmmmm  ----PP    
             -Ek!_```bbbb``bb``bbbb----UU    
             }6,`^26666``````````66----66    
             EE``1EEEEEEE``EE``EEEE----99    
             Jy_.=eyyyy..........yy----ww    
             _Il~_---oooo--oo--oooobbbbbb    
              `;7x111111111111111


                                             
                 33333333333333I/`           
                 uu''''''''''''^su/`         
                 oo--------------~Jo*`       
                 55----        ----~l2+`     
                 aa----        ------~ta+    
                 SS----            ----SS    
                 kk----            ----kk    
                 kk----            ----kk    
              `!xOmmmmmmmmmmmmmmm  ----PP    
             -Ek!_```bbbb``bb``bbbb----UU    
             }6,`^26666``````````66----66    
             EE``1EEEEEEE``EE``EEEE----99    
             Jy_.=eyyyy..........yy----ww    
             _Il~_---oooo--oo--oooobbbbbb    
              `;7x111111111111111


                                             
                 33333333333333I/`           
                 uu''''''''''''^su/`         
                 oo--------------~Jo*`       
                 55----        ----~l2+`     
                 aa----        ------~ta+    
                 SS----            ----SS    
                 kk----            ----kk    
                 kk----            ----kk    
              `!xOmmmmmmmmmmmmmmm  ----PP    
             -Ek!_```bbbb``bb``bbbb----UU    
             }6,`^26666``````````66----66    
             EE``1EEEEEEE``EE``EEEE----99    
             Jy_.=eyyyy..........yy----ww    
             _Il~_---oooo--oo--oooobbbbbb    
              `;7x111111111111111

CSharpDestructor Themed Icon generated identifiers: — identifier class, for use in attributes, XAML, and generic parameters; — identifier object, as a field in the identifier class, for use where an value is expected.


                                             
                        -;+LTl^ :?Chhh!      
                        ~IekEhhh|". !h!      
                        ^t!-!t^     !h!      
                        ^t!-!t^     !h!      
                    `_=cTtttttTc=_`          
                  `_/tt{^ ~1=`=o31*_`        
                  ,cTl^ "t^ ~I=`!kfc,        
                `_/t~`~l" ^{~`!E+'=t/_`      
                '^+tt}~`~C~`=5/.cDKt+^'      
                '^+t=.;3=`!y/.rGc-!t+^'      
                `_/t3y/'+P+-LG)_78Ut/_`      
                  ,c=-Lbc:|O7^}%C~/c,        
                  `_*Ir"sDt~{8C=cu+_`        
                    `_=cTtttttTc=_`

For details on Themed Icons and their use, see Remarks on the outer class. <Image Source="{icons:ThemedIcon myres:PsiCSharpThemedIcons+CSharpDestructor}" />  [Item(Name="Sample", Icon=typeof(PsiCSharpThemedIcons.CSharpDestructor))] // C# Type attribute IconId iconid = PsiCSharpThemedIcons.CSharpDestructor.Id; // IconId identifier object themediconmanager.GetIcon<PsiCSharpThemedIcons.CSharpDestructor>() // Icon image for rendering identifier class

Loads the image for Themed Icon CSharpDestructor theme aspect SymbolsIdea.

Loads the image for Themed Icon CSharpDestructor theme aspect SymbolsVs08.

Loads the image for Themed Icon CSharpDestructor theme aspect SymbolsVs11Color.

Loads the image for Themed Icon CSharpDestructor theme aspect SymbolsVs11Gray.

Loads the image for Themed Icon CSharpDestructor theme aspect SymbolsVs11GrayDark.

Returns the set of theme images for Themed Icon CSharpDestructor.

CSharpIndexer Themed Icon generated identifiers: — identifier class, for use in attributes, XAML, and generic parameters; — identifier object, as a field in the identifier class, for use where an value is expected.


                                             
                        `-=LLL=-`            
                      `-=c~...~|=-`          
                    `-=c~.`   `.=7!-`        
                  `-=L^.`       `.=t!-`      
                `-=?^.`   ~II3~  ``';C/-`    
              `-=?^.`     ~333~ ````.-!]/-`  
              :r^.`      ``---.``....`.-!]~  
              ,c~.`    ```=oo2=``''-..'-!]~  
              `-;T='` ````;255;`.-'.'-!]/-`  
                `-!7=-````!aaS!``.--!]/-`    
                  `-!l=-.`~JT)^`.-!]/-`      
                    `-!};-'`..'-!]/-`        
                      `-/C!---!]/-`          
                        `-/]]]/-`

For details on Themed Icons and their use, see Remarks on the outer class. <Image Source="{icons:ThemedIcon myres:PsiCSharpThemedIcons+CSharpIndexer}" />  [Item(Name="Sample", Icon=typeof(PsiCSharpThemedIcons.CSharpIndexer))] // C# Type attribute IconId iconid = PsiCSharpThemedIcons.CSharpIndexer.Id; // IconId identifier object themediconmanager.GetIcon<PsiCSharpThemedIcons.CSharpIndexer>() // Icon image for rendering identifier class

Loads the image for Themed Icon CSharpIndexer theme aspect SymbolsIdea.

Loads the image for Themed Icon CSharpIndexer theme aspect SymbolsVs08.

Loads the image for Themed Icon CSharpIndexer theme aspect SymbolsVs11Color.

Loads the image for Themed Icon CSharpIndexer theme aspect SymbolsVs11Gray.

Loads the image for Themed Icon CSharpIndexer theme aspect SymbolsVs11GrayDark.

Returns the set of theme images for Themed Icon CSharpIndexer.

LocalFunction Themed Icon generated identifiers: — identifier class, for use in attributes, XAML, and generic parameters; — identifier object, as a field in the identifier class, for use where an value is expected.


                                             
                         `~7wbs;`            
                      :ryRZ[Lr{Emkc,         
                  .![Abu);;;;;;;;LCwmf\-     
                 6D[T!""""""""""""""!T}Db    
               `:juvTrLr;::::::::~;: -"DD    
              ^}(^.``._LF;_~::~_``";^_:DD    
             ~C! -L3u): ~C):  :;=;;~^_:88    
             vu-`{SSSS2``u3_,+*=!;;~^_:88    
             ;5!`:Ll}c"`~57_,+*=!;;~^_:88    
              TS~......,j2~_,+*=!;;~~*{W8    
              `xk"----:eS;"_,+*=!+}X8HJ^`    
               .eE_--:eXDDS)~r}kD82=.        
                :Uk_:54: :cZ%B6|,            
                 :bV2p^                      
                  ~OO\

For details on Themed Icons and their use, see Remarks on the outer class. <Image Source="{icons:ThemedIcon myres:PsiCSharpThemedIcons+LocalFunction}" />  [Item(Name="Sample", Icon=typeof(PsiCSharpThemedIcons.LocalFunction))] // C# Type attribute IconId iconid = PsiCSharpThemedIcons.LocalFunction.Id; // IconId identifier object themediconmanager.GetIcon<PsiCSharpThemedIcons.LocalFunction>() // Icon image for rendering identifier class

Loads the image for Themed Icon LocalFunction theme aspect Color.

Loads the image for Themed Icon LocalFunction theme aspect Gray.

Loads the image for Themed Icon LocalFunction theme aspect GrayDark.

Returns the set of theme images for Themed Icon LocalFunction.

AllParameters Themed Icon generated identifiers: — identifier class, for use in attributes, XAML, and generic parameters; — identifier object, as a field in the identifier class, for use where an value is expected.


                                             
                `Tjjjj;   `_royc"` _jjjjv.   
               :21.;y* -!zUl;"^;}Xz!*y\`Jo^  
              :y} -y[)Vkc^^LXD8O~`^ww7a: Ta^ 
             `e3` tV'pp  '!IVc_    pp`22` }V'
             /E~ _EL RR_`       :/3RX =E; :E)
             xh.`rh^ XDqR{;.`~vbqv=DD :hv``hy
             2X'`3X. 88`-+j88Zc,```88  XZ``XX
             36-`T6_ WW~```'-```_LkWA -6x``6P
             L9;`;9L dBD8o=--!tDDtrBB !9*`"9i
             -be--XK`$$.:cX$$dv~...$$ y9:.tb_
              !HI-;HtQQ!-..:,...~7bQb7H*'JH? 
               \bo:TqF}8QXL,:re$$e!`;q[:tqc  
                :UGGGG; -|AggDJ_   ,dGGGX^

For details on Themed Icons and their use, see Remarks on the outer class. <Image Source="{icons:ThemedIcon myres:DekalunThemedIconsThemedIcons+AllParameters}" />  [Item(Name="Sample", Icon=typeof(DekalunThemedIconsThemedIcons.AllParameters))] // C# Type attribute IconId iconid = DekalunThemedIconsThemedIcons.AllParameters.Id; // IconId identifier object themediconmanager.GetIcon<DekalunThemedIconsThemedIcons.AllParameters>() // Icon image for rendering identifier class

Loads the image for Themed Icon AllParameters theme aspect Color.

Loads the image for Themed Icon AllParameters theme aspect Gray.

Loads the image for Themed Icon AllParameters theme aspect GrayDark.

Returns the set of theme images for Themed Icon AllParameters.

Stores information whether the file possibly contains collection expressions.

Exposes queries to a cache of alias directives.

Returns files possibly declaring alias with the specified name.

Alias name. Optional predicate of source files.

Returns files possibly declaring alias to the specified symbol.

Aliased symbol. Optional predicate of source files.

Creates a searcher to find using alias directives in a specified file.

Allows to find using alias directives for the specified type usages, types, or namespaces.

Finds a single available alias for the specified type usage.

Finds a single available alias for the specified reference name.

Finds a single available alias for the specified reference expression.

Finds a single available alias for the specified predefined type expression.

Finds a all aliases for the specified type.

Finds a all aliases for the specified namespace.

Stores information whether the file possibly contains target-typed new expressions.

Do not use directly in features. Use

types with type arguments, arrays, pointer type, etc.

A strongly-typed resource class, for looking up localized strings, etc.

Returns the cached ResourceManager instance used by this class.

Overrides the current thread's CurrentUICulture property for all resource lookups using this strongly typed resource class.

Looks up a localized string similar to <Patterns xmlns="clr-namespace:JetBrains.ReSharper.Psi.CSharp.Impl.CodeStyle.MemberReordering;assembly=JetBrains.ReSharper.Psi.CSharp"> <TypePattern DisplayName="COM interfaces and structs"> <TypePattern.Match> <Or> <And> <Kind Is="Interface" /> <Or> <HasAttribute Name="System.Runtime.InteropServices.InterfaceTypeAttribute" /> <HasAttribute Name="System.Runtime.InteropServices.ComImport" /> </Or> </And> <Has [rest of string was truncated]";.

Looks up a localized string similar to <Patterns xmlns="clr-namespace:JetBrains.ReSharper.Psi.CSharp.Impl.CodeStyle.MemberReordering;assembly=JetBrains.ReSharper.Psi.CSharp"> <TypePattern DisplayName="COM interfaces or structs"> <TypePattern.Match> <Or> <And> <Kind Is="Interface" /> <Or> <HasAttribute Name="System.Runtime.InteropServices.InterfaceTypeAttribute" /> <HasAttribute Name="System.Runtime.InteropServices.ComImport" /> </Or> </And> <HasA [rest of string was truncated]";.

Looks up a localized string similar to <?xml version="1.0" encoding="utf-8"?> <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:msxsl="urn:schemas-microsoft-com:xslt" xmlns="urn:shemas-jetbrains-com:member-reordering-patterns" xmlns:x="urn:shemas-jetbrains-com:member-reordering-patterns" exclude-result-prefixes="msxsl x"> <xsl:output method="xml" indent="yes" /> <xsl:template match="x:Patterns"> <Patterns> <xsl:apply-templates /> </Patterns> </xsl:template> [rest of string was truncated]";.

Provide custom indentation for the node to format correctly in ASP/Razor

node to get the indent for type of requested custom indent null if default indentation should be used, or string which will be used as an indent

Used for storing and managing of code style settings

Gets braces code style suggestions for 'then' part of 'if'-statement.

true if braces should be added, false if braces should be removed, null - do nothing.

Gets braces code style suggestions for 'else' part of 'if'-statement.

true if braces should be added, false if braces should be removed, null - do nothing.

Gets the top code style suggestion in 'If'-statement chain. Returns current suggestion if it is a top or there is no 'If'-statement chain.

Note: doesn't present nullable annotations

Attached to edge which exits from 'finally' block

'try' statement itself

That edge which exits from 'try' block

Attached to edge which exits from 'finally' block

That edge which exits from 'try' block

This method doesn't unwrap nested conversions recursively. Callers must either unwrap them themselves or call instead. It might be useful in case you expect some nested conversions that match converted expressions e.g. when converting switch expressions you'll get a conversion per switch expression arm without their nested conversions.

Classifies conversion from to . Considers built-in and user-defined implicit conversions.

Classifies conversion from to . Considers all kind of conversions including explicit and user-defined

It is rare but possible for a source type to be convertible to a destination type by both an implicit user-defined conversion and a built-in explicit conversion. In that circumstance, this method classifies the conversion as the invalid explicit conversion

Following implicit and explicit conversions are considered builtin: Identity, Reference, Numeric, Boxing, Unboxing, Pointer, Dynamic, Tuple, Nullable

Valid implicit builtin conversions are strict subset of standard implicit conversions. In case of tuple conversions the method might check for multiple user-defined operators

Classifies conversion from to . Considers built-in and user-defined implicit conversions.

Classifies conversion from to . Considers all kind of conversions including explicit and user-defined

For constant expression types it may return explicit conversion which will be compiler error in checked contexts. It is rare but possible for a source type to be convertible to a destination type by both an implicit user-defined conversion and a built-in explicit conversion. In that circumstance, this method classifies the conversion as the invalid explicit conversion

This method exists for performance reasons only as it doesn't check for user-defined conversions This method only checks following conversion kinds: Identity, ImplicitReference, Boxing, ImplicitTuple, ImplicitTupleLiteral, ImplicitSpan

The actual source type used which was converted to the operator's source type via the conversion stored in the SourceConversion field

The actual target to which the operator's result type was converted via the conversion stored in the TargetConversion field

Factory for C# tree nodes creation. Format string is specified with $0, $1, ... as placeholders for arguments

See 'GeneratedCodeUtilities.cs' in Roslyn.

collection expressions primary constructors ref readonly parameters lambda default parameters using aliases for any type inline arrays nameof accessing instance members Experimental attribute interceptors (experimental feature)

params-collections escape character Lock object method group natural type improvements implicit indexer access in object initializers

field keyword in properties

extensions field keyword in properties unbound generic types in nameof first-class Span types simple lambda parameters with modifiers

NOTE: Use only for features that are not merged into the 'main' branch of Roslyn i.e. their fate is not clear yet

Represents the aliased namespace or type.

The equality comparer using all the language strictness but ignoring top-level nullability.

An unknown aliased symbol.

Constructs the aliased symbol from namespace.

Constructs the aliased symbol from type.

Gets the aliased namespace or value null if this is not a namespace alias instance.

Gets the aliased type or value null if this is not a type alias instance.

Value indicating whether the aliased symbol is unknown.

Returns value true if aliased type is unknown.

Value indicating whether the aliased symbol is resolved.

In case of type alias acts like i.e. checks if substitution if any is also resolved.

Checks whether the alias refers to a namespace or a regular declared type.

See documentation of the for a regularity definition.

Checks whether the alias refers to a regular declared type.

A declared type is considered regular unless it's one of the following cases: dynamic type native numeric type without runtime support tuple type with named components on top-level

Checks if the aliased symbol is successfully resolved to a namespace or a regular declared type and returns the corresponding declared element and substitution.

See documentation of the for a regularity definition.

Checks if the aliased symbol is successfully resolved to a regular declared type and returns the corresponding type element and substitution.

See documentation of the for a regularity definition.

Creates a declared element instance if the aliased symbol refers to a namespace or a regular declared type.

See documentation of the for a regularity definition.

Checks if the aliased symbol refers to the same declared element as specified parameter.

Checks if the aliased symbol refers to the same declared element instance as specified parameter.

Checks if the aliased symbol refers to the same type as specified parameter.

Checks if the aliased symbol refers to the same namespace or type as other aliased symbol.

Checks if the property accessors contain the reference to 'field' keyword. Only works for declared elements from source code.

Represents the declared element of a 'using' alias.

The aliased namespace or type.

Value indicating whether the alias is declared in global using directive.

Value indicating whether the aliased symbol is a namespace or a regular declared type.

A symbol alias can refer either to a namespace, or to a type. Before C# 12 alias could refer only to a "regular" declared type fully constructed and defined by its and . C# 12 allowed to alias any type including array types, pointer types, function pointer types, tuple types, dynamic types, nint/nuint (with and without runtime support). Usages of aliases to namespaces and "regular" declared types are transparent and resolved directly an aliased symbol. Getting the used for resolving a usage of symbol alias is possible from a through the extension method. Usages of aliases to complex types are resolved to a .

Extern alias used for the aliased symbol.

Gets declarations of the symbol alias.

typeKeyword should be type of token of one of predefined types.

Marker interface to detect if some declared element is declared as a C# 9.0 record. Only source code declared records do implement IRecord, so use this interface only in source code scenarios.

Default in file.

Generated files has disabled nullable context by default, all other files by default have nullable context specified in project configuration.

Enabled.

Disabled.

Restored to project defaults.

Allows to check if lexer is currently in a context with evident type e.g. `T x = {here}`.

Type

Type x

GenericType

GenericType x

object

object x

T Foo(

T Foo()

T Foo(U

T Foo([

T Foo([NotNull

T Foo([NotNull]

T Foo(U arg

T Foo(U arg,

get

get;

get; }

'Type x = ' or 'GenericType x =>' or 'object x ='

Try to parse the preprocessor directive from given lexer up to given limit. Returns parsed tree node, or null if none

true if the current token can be the first token of a typed identifier (a type name followed by an identifier), false if it definitely can't be, null if we need to scan further to find out.

Special variant of parsing routine allowing parsing optional comma

Definitely not a type name.

Definitely a type name: either a predefined type (int, string, etc.) or an array type name (ending with a bracket).

Might be a generic (qualified) type name or a method name.

Might be a generic (qualified) type name or an expression or a method name.

Might be a non-generic (qualified) type name or an expression.

A type name with alias prefix (Alias::Name)

Nullable type (ending with ?).

Might be a pointer type or a multiplication.

Might be a tuple type.

Similar to but with additional declaration context check: if token is 'async' then it also looks ahead for 'async Task()' constructions where 'async' is NOT a keyword

Parse expected lambda expression but assume `x ? () => y :` is a conditional expression rather than a lambda expression with an explicit return type and return null in that case only.

Checks two cases: * Implicitly typed lambdas: `(a, b) =>` * Simple explicitly typed lambdas: `(A a, B b) =>` More complex scanning of parenthesized lambdas happens in

Source text must be UNescaped (no xml entities)

Special token for some implementation details. It should never be returned from C# lexer

Implicit `Foo` property generated from `record R(int Foo);` `null` if there is a member that matches primary parameter by name and it used insetead of generating the implicit property. Implicit generated property may override abstract property from base record type.

Explicit `Foo` property in `record R(int Foo) { public int Foo { get; } }` Explicit `Foo` field in `record R(int Foo) { public int Foo; }` Explicit property/field may not actually be initialized by `Foo` primary parameter. May be explicit property/field in a base record type. `null` if there is no member that matches primary parameter by name and implicit property is generated.

Implicit generated property may override abstract property from base record type: `abstract record B { public abstract int Foo { get; init; } } + record D(int Foo) : B;`

Substition for use with `ExplicitDeclarationMember`/`OverridenBaseProperty`, since those members can be from base (possibly generic) record type.

Resolve info for extension property invocation.

Resolve result corresponding to the extension property itself.

Resolve result corresponding to the invocation of an extension property, i.e., delegate or function pointer invocation.

Resolve status corresponding to the invocation of an extension property.

Offset of the reference start from the comment

Obtains the range of the signature (i.e (...))

Overrides default resolve algorithm for given IReferenceName

reference to resolve result of resolution, or null to resolve reference by default algorithm

"better function member" is defined in "C# Language Specification", 14.4.2.2 NOTE: Both methods should be applicable!

returns +1 if method1 is better function member for arguments returns -1 if candidate2 is better function member for arguments returns 0 otherwise

Corresponds to Roslyn's `OverloadResolution.GetParameterBetternessRefKind`.

This is a comparer that ignores differences in dynamic-ness and tuple names. But it has a special case for top-level object vs. dynamic for purpose of method type inference.

The type of 'var x' declaration expression in 'M(out var x)' The type of '_' reference expression in 'M(out _)' and '(_, _) = tuple'

Type of interpolated string concatenations e.g. ($"string1" + $"string2") + $"string3"

The natural type is 'string'. Implicitly convertible to interpolated string handler types. No conversion to 'IFormattable'/'FormattableString'.

We're ignoring 'params' modifier on a parameters, which are called from a different module of a C#12 or lower language version or when required members are missing: e.g. there is no default .ctor for ImplementsIEnumerable kind

Checks for patterns like if (b1 && ... && lastExpression) { ... } else { ... } or if (b1 && ... && !lastExpression) { ... } else { ... } or if (b1 || ... || lastExpression is false) { ... } else { ... } etc. and finds the statement or expression (`Then` or `Else` or effective `Else`) that is executed right after `lastExpression` check with target value with a guarantee that check over `lastExpression` is actually performed.

`true`, if target branch is `Then` `false`, if target branch is `Else` `null`, if can't find target branch

is implicitly convertible to 'CancellationToken' type.

is similar to .

A character after the backslash to interpret. E.g. 'n' from '\n'. Unicode escapes like '\u' and other will result in returning of false. C# language level; omit for 'latest' and parsing forward-compatible. Resulting one-char string (in order to make is intern-able).

Allows to check whether the file or a closed chameleon node contains possibly contains a collection expression.

Means that synchronization context will be captured (if exists) and the continuation will be marshaled back to it. Corresponds to `.ConfigureAwait(true)` and `.ConfigureAwait(ConfigureAwaitOptions.ContinueOnCapturedContext)`

Means that synchronization context will not be captured. Corresponds to `.ConfigureAwait(false)` and `.ConfigureAwait(ConfigureAwaitOptions.None)`

Means that `ConfigureAwait` invocation can only configure context capturing behavior. Corresponds to `.ConfigureAwait(bool)` with any boolean value and to the `.ConfigureAwait(ConfigureAwaitOptions)` when it only contains `ConfigureAwaitOptions.None` or `ConfigureAwaitOptions.ContinueOnCapturedContext`

Corresponds to any `ConfigureAwait` invocation, such as `.ConfigureAwait(ConfigureAwaitOptions.SuppressThrowing)`, `ConfigureAwait(ConfigureAwaitOptions.ForceYielding | ConfigureAwaitOptions.ContinueOnCapturedContext)`, etc. Note, that it can significantly change semantics. For example, `ConfigureAwaitOptions.SuppressThrowing` will suspend exception propagation and the exception will be only accessible using the original `Task` object.

Returns .ConfigureAwait(bool) method if it exists for specified

Determines whether element is inside setter/adder/remover

Divide attribute sections into groups with the same target

Plain array of sections Groups of attribute sections with the same target

Returns element type if collection type is a collection type (described in specification, 15.8.4) otherwise, returns null

Check if the member is visible as C# type member I.e. it skips accessors except to properties with parameters

Check if given declared element is part of closure in respect to given access expression

Utility class for working with expressions

Check if the expression could be used as boolean condition, i.e. implicitly convertible to bool, or contains true/false operators.

Unwraps expression from parenthesis and parentheses-like expressions namely checked(), unchecked() and ! (nullable warning suppression) If semantics such as overflow checks or nullability warnings/errors should be preserved use

Unwraps expression from parenthesis. If you need to also unwrap it from other parentheses-like expressions that might change semantics such as checked(), unchecked() and ! (nullable warning suppression) use

Check if this expression should be enclosed in parentheses if it will be replaced by 'newExpression'

Check if this expression is precondition, i.e. something like


            Logger.Assert(nonNullableEntity != null, "The condition (nonNullableEntity != null) is false.");
            -or-
            if (nonNullableEntity == null)
                throw Exception();
            -or-
            if (nonNullableEntity == null)
            Logger.LogError();

At the beginning of the method

Check if this expression is precondition, i.e. something like


            Logger.Assert(nonNullableEntity != null, "The condition (nonNullableEntity != null) is false.");
            -or-
            if (nonNullableEntity == null)
                throw Exception();
            -or-
            if (nonNullableEntity == null)
            Logger.LogError();

At the beginning of the method

Tries to guess expression type which will be at runtime. Usually returns expression.GetExpressionType, but recognize few special cases

For cases like `UnresolvedInvocation([no, target, type, yet])`.

Port of Roslyn's BoundExpressionExtensions.GetRefKind.

Check that any custom conversion operator could exist from to According to C# specs 17.9.3. Both and should be unlifted

Creates a new instance of CharEscape

Checks if the specified type requires unsafe context.

Before C# 12 compiler checked only for pointer/function pointer types and arrays of pointers and didn't check deeper (e.g. pointers inside type arguments 'List<int*[]>'). C# 12 compiler fixes this behavior and performs the deep check for pointer types. However Roslyn does it disregarding the language version flag except in inside of type argument list. The backward compatibility is inconsistent but Roslyn is not going to fix it (https://github.com/dotnet/roslyn/issues/69422).

Check if this type is unmanaged type: * sbyte, byte, short, ushort, int, uint, long, ulong, char, float, double, decimal, or bool. * Any pointer-type. * Any enum-type. * Any user-defined struct-type that contains fields of unmanaged-types only * A type parameter with 'unmanaged' constraint

Check that type can be declared explicitly in code

C# specs 23.5: Check type for variance safety

Empty enumerable if type passes variance check Pairs of type parameter and necessary variance if type failed check

C# specs "10.5.3 Volatile fields" • A reference-type. • The type byte, sbyte, short, ushort, int, uint, char, float, bool, System.IntPtr, or System.UIntPtr. • An enum-type having an enum base type of byte, sbyte, short, ushort, int, or uint.

Returns true if the tests are related i.e. they have the same input, otherwise false.

The pre-condition under which these tests are related. A possible assignment node which will correspond two non-identical but related test inputs.

Is the pattern in a state in which it is fully matched and there is no when clause?

Is the pattern fully matched and ready for the when clause to be evaluated (if any)?

Is the clause impossible? We do not consider a when clause with a constant false value to cause the branch to be impossible. Note that we do not include the possibility that a when clause is the constant false. That is treated like any other expression.

Rewrite nested length tests in slice subpatterns to check the top-level length property instead.

Produce a sample value contained in the set. 'ArgumentException' if the set is empty. If the set contains values but we cannot produce a particular value (e.g. for the set 'nint > int.MaxValue'), returns null.

Detects generated C# code in Razor codebehind tree

Returns true if this invocation is skipped by compiler, because of partial method without implementation, or conditional method

Unicode character to present MUST BE either escape sequence or null. If provided, will be the preferred way to express the escape sequence, e.g. \u0020 or \x20 will be used instead of space character. Will not be used if target literal doesn't support such an escape sequence. A character to present iff this method returned null

Provides validation and conversion of string literals.

""" ^

"""... ^

""" text ^ """

{{ ^

}} ^

""" text more text ^ """

""" text """ ^

Invalid token from a current position

Provides API to traverse local functions' calls and caches results when it's possible. Handles unfinished, recursive and mutually recursive local functions. Regular recursion and non-recursive interprocedure calls do not affect the complexity. Common case without mutual recursion is O(N). Worst case where each pair of local functions is mutually recursive is O(N^2) Local1(); - push to call stack and analyze Local2(); - push to call stack and analyze Local3(); - push to call stack and analyze Local2(); - use 'recursive' info and mark Local3 as not finished, cache it temporarily Local3(); - use temporarily cached 'Local3' Local3(); - use temporarily cached 'Local3' - drop temporariy cache Local1(); - use 'recursive' info Local2(); - use cached info for Local2 (already processed in its previous call) Local3(); - push to call stach and analyze (temporary cache has been dropped) Local2(); - use cached info Local1(); - use cached info Local2(); - use cached info Local3(); - use cached info

True for reference equality and a few known ways of null checking e.g. equality operators with known behavior, Nullable.HasValue. False if null check may have side effects or return unexpected result e.g. is user defined or dynamic.

Converter from an object creation expression creating a 'ValueTuple' instance into a tuple expression.

Turns properties/indexers without accessor declarations (like 'string Text => _text;') into ordinary property/indexer with accessor holder ('string Text { get => _text; }'), so it would be safe to iterate over collections.

This method do not adds accessors if there were no accessors previously, however unfinished expression body (like 'string Text =>') would produce getter declaration.

Ensures there is a block around passed statement. Preserves statement node identity and validity

Ensures there is a statement owner (block or 'switch' section) around passed statement. Preserves statement node identity and validity

Assumes that for would return true. Alternatively, you may check if returns true and then call .

Ensures there is a statement containing passed expression, possibly converting containing expression-bodied lambda-expression or type member in statement-bodied form. Preserves expression node identity and validity.

Provides base functionality to check if file or a closed chameleon node contains a specific kind of expression.

Checks whether the given node is the required one.

Checks if a closed chameleon node possibly contains the required expression.

Lexer of a closed chameleon node. true if required expression is found only in type-evident contexts; otherwise false. Value indicating whether the closed chameleon node possibly contains a required expression.

Checks whether the file possibly contains the required expression.

A file to search in. true if required expression is found only in type-evident contexts; otherwise false. Value indicating whether the file possibly contains a required expression.

Allows to check whether the file or a closed chameleon node contains possibly contains a target-typed new expression.

According to C# specs 7.10.10 + improvisation for pattern-matching

Checks to see whether an expression is a "moveable" variable according to the spec. Moveable variables have underlying memory which may be moved by the runtime. The spec defines anything not fixed as moveable and specifies the expressions which are fixed.

Expression classified as mutable or read-only variable. Cache to share closure variables * C# specification 18.3 "Fixed and movable variables" * handling of C# 7.x features like 'in'-parameters, 'ref'/'ref readonly' variables * C# 7.3 introduced new rule for moveability of pointer element access (see https://github.com/dotnet/roslyn/pull/28527/)

Checks whether the symbol alias is accessible in a given context.

Finds nodes which can be replaced with the alias.

Gets the predicate to check if a source file can contain the aliased symbol.

Checks if a node refers to the original aliased symbol.

Nodes refering to some symbol alias aren't considered equivalent to the original aliased symbol because we don't want to replace one symbol alias with another.

Collects names and aliased symbol names of using aliases in file.

Get the empty XML doc template for the given element.

XML text without any comments (i.e. "///") and initial cursor position.