JetBrains.ReSharper.Daemon.CSharp

definitely has only 1 declaration.

is delegate. Func, Action, event also returns true.

is func with any number of type parameters.

is action with any number of type parameters.

is event or delegate.

is delegate. Func, Action, event also returns true.

is function, local function or anonymous method.

can be executed.

Returns call graph lambdas that can be result of evaluating example: ((Object) (condition ? (a as SomeClass) : (b ?? c))) then ExtractDeclaredElement would return [a, b, c]

Returns elements that can be result of evaluating example: ((Object) (condition ? (a as SomeClass) : (b ?? c))) then ExtractDeclaredElement would return [a, b, c]

String presentation for in call graph

Extracts call graph invocable entity from

Collection of all type members of the class being inspected. Only members of the class part being expected has declarations in the value of the dictionary

Enumerate members which could be overridden in this class. NOTE: call this method only before inspection

Enumerate all members from the interfaces of the given class. NOTE: call this method only before inspection

Check if the given member of direct interface is quasi implemented

Analyze which interface members are implemented by this class. The implementation check should be weak, because accessibility and type mismatch problems will be highlighted elsewhere

predicate: inheritor and parent must have same name

Get all interface members which could be implemented by the given class member The candidates are categorized into two groups - with match of return type, and candidates when return type didn't match

Enumerate all members from the interfaces of the given class. NOTE: call this method only before inspection

We need to repeat some syntax style after formatting code, because it can change line breaks

ReSharper allow some naming rules that are impossible in Roslyn, so we should adjust them before converting 1. ReSharper rules could specify fields that are not readonly or const. In Roslyn we must specify rule for all fields + overrides for readonly/const fields. 2. ReSharper rules could be specified for strange bedfellows, like const fields together with local non-const variables. It's not possible to do in Roslyn, so we have to separate them.

Intended for compiler errors and warnings. For lambda parameters analysis . For simplification suggestions . For conversion to local function .

Check for arrays in array initializer.

Sizes of the array. Element == -1 for open array. Array size is the rank ot the array true if the initializer is a part of imlicitly typed array creation expresison Number of initializer elements in the array (for each dimension)

Searches for an instance method of a collection type or an extension method from CollectionExtensions

According to paragraph 25.2.1 of C# specs

Checks for patterns like this:


            if (!dict.TryGetValue(key, out value))
              value = default;

Checks for patterns like this:


            if (dict.TryGetValue(key, out var value))
              return value;
            else
              return default;

Checks for patterns like this:


            if (dict.TryGetValue(key, out var value))
              destination = value;
            else
              destination = default;

Checks for patterns like this:


            if (!dict.TryGetValue(key, out var value))
              value = default;

Finds assignments inside loop conditions and suggests using pattern matching instead when appropriate. For example, if you apply the corresponding QF, the following code while ((o = Next()) != null) gets rewritten as while (Next() is { } o)

There is special treatment for 'GetEnumerator()' methods, like 'foreach' does it: assume disposing is not required iff enumerator is sealed/struct and doesn't have 'Dispose()' method, e.g. see 'System.Span[T].GetEnumerator()'. Same for 'GetAsyncEnumerator()'/'DisposeAsync()' things.

In some cases, object creation could be redundant. (For example, delegate creation and nullable type conversion) Check that!

Returns the set of arguments to be considered for escape analysis of a method invocation. Each argument is returned with the corresponding parameter and whether analysis should consider value or ref escape. Not all method arguments are included, and some arguments may be included twice - once for value, once for ref.

Creates matchers on demand if C# language is available

True if there is C# language, false otherwise

May become either or later.

error CS1009: Unrecognized escape sequence

error CS8086: A '}' character must be escaped (by doubling) in an interpolated string

error CS8087: A '}' character may only be escaped by doubling '}}' in an interpolated string

to report; if empty, all kinds are to be reported.

This will analyze semantic problems in XML documentation Resolve errors are highlighted in

Detects the case of recursive lambda declaration: Action lambda = null; lambda = () => { lambda(); };

According to C# specs 22.3

Run GutterMarkNetTest if you are going to change instantiation

Base class for daemon stages which can incrementally re-highlight changed function only

Base class for daemon stage processes which can incrementally re-highlight changed function only

TODO: doc

Returns whether a source file is included or not if applicable. Included files are skipped by imports usage analysis.

PSI source file: not null, valid and supports C# language file is included true if applicable and false otherwise

Compare the accessibility rights and returns false if is less accessible then , which means that the error should be highlighted according to C# specs 10.5.2

This parameter is set to true when control flow analysis checks that constant initializer isn't used at any execution path

Implements Johnson algorithm to enumerate simple cycles inside a graph

Checks if the given short name is suspicious (i.e., present in vulnerable full qualified method names). Used to reduce the number of intensive PSI calls by retrieving FQN.

Checks if the fully qualified name (FQN) is vulnerable.

Finds vulnerability reports for the given type FQN and short name.

Indicates whether resolve for redundant qualifier check should be done If the daemon incrementally highlights method body, then only this body should be checked

According to C# specs 25.7.1

Check that constraints clasuses are subject for further analysis, i.e. all parsed properly

just optimizations, since asking type of every expression is too expensive

C# specs 18.6 - special rules for fixed pointer initializer + improvisation for C# 7.3 (see https://github.com/dotnet/csharplang/blob/master/proposals/csharp-7.3/pattern-based-fixed.md)

This class and it's extension methods provide a DSL that is used to describe how external (mainly, Roslyn-based) inspections' severities should be mapped to the ReSharper code style settings schema and ReSharper inspections' severities.

Used for old (StyleCop.Settings) properties support. Compat-only! If a modern inspection id is not found, returns the passed name of the StyleCop.Settings property.

Highlights C# contextual keywords, doc comments

In some scenarios we should not suggest using collection expression, because it can lead to inconsistent syntax after applying a series of QFs var xs = f ? new[] { 1 } : new[] { 2 }; Although we can replace both nested array creations separately, we cannot do it at the same time, because the type of the outer ternary expression will not be able to resolve

Expression to analyze If it is aesthetically recommended to use collection expression on a given expression

A declaration marked with this attribute will be recognized as a CQRS Command. Its name and compliance with the CQRS pattern will be validated.


            public class User
            {
              private string Name;
              [CqrsCommand]
              void SetUserNameCommand(string newName) 
              {
                if (newName == GetUserName()) //Warning about "GetUserName" is called from Command but belongs to the Query
                  return;
                Name = newName;
              }
            
              [CqrsQuery]
              string GetUserName() //Suggestion to rename it to the GetUserNameQuery and Quickfix for it
              {
                return Name;
              }
            }

A declaration marked with this attribute will be recognized as a CQRS Query. Its name and compliance with the CQRS pattern will be validated.


            public class User
            {
              private string Name;
              [CqrsCommand]
              void SetUserNameCommand(string newName) 
              {
                if (newName == GetUserName()) //Warning about "GetUserName" is called from Command but belongs to the Query
                  return;
                Name = newName;
              }
            
              [CqrsQuery]
              string GetUserName() //Suggestion to rename it to the GetUserNameQuery and Quickfix for it
              {
                return Name;
              }
            }

A declaration marked with this attribute will be recognized as a CQRS CommandHandler. Its name and compliance with the CQRS pattern will be validated.


            [CqrsCommandHandler]
            public class UserCommandHandler
            {
              void Handle(SetUserNameCommand command)
              {
                var query = new GetUserNameQuery() { Id = command.Id}; //Warning about using Query inside Command
                var handler = new UserQuery(); //Warning about using Query inside Command
                if (command.Name == handler.Handle(query)) //Warning about using Query inside Command
                  return;
                // ... implementation
              }
            }
            
            [CqrsQueryHandler]
            public class UserQuery //Suggestion to rename to the UserQueryHandler
            {
              public string Handle(GetUserNameQuery query) 
              {
                return "";
              }
            }

A declaration marked with this attribute will be recognized as a CQRS QueryHandler. Its name and compliance with the CQRS pattern will be validated.


            [CqrsCommandHandler]
            public class UserCommandHandler
            {
              void Handle(SetUserNameCommand command)
              {
                var query = new GetUserNameQuery() { Id = command.Id}; //Warning about using Query inside Command
                var handler = new UserQuery(); //Warning about using Query inside Command
                if (command.Name == handler.Handle(query)) //Warning about using Query inside Command
                  return;
                // ... implementation
              }
            }
            
            [CqrsQueryHandler]
            public class UserQuery //Suggestion to rename to the UserQueryHandler
            {
              public string Handle(GetUserNameQuery query) 
              {
                return "";
              }
            }

Indicates that the marked element must be excluded from CQRS-related analysis.


             public class User
             {
               private string Name;
               [CqrsCommand]
               void SetUserNameCommand(string newName) 
               {
                 if(newName == GetUserName()) //Warning about "GetUserName" is called from Command but belongs to the Query
                   return;
                 Name = newName;
                 CheckName();
               }
             
               [CqrsQuery]
               string GetUserName() //Suggestion to rename it to the GetUserNameQuery and Quickfix for it
               {
                 CheckName();
                 return Name;
               }
            
               [CqrsExcludeFromAnalysis]  
               bool CheckName() //Although this metod is used both in Command and Query, will be ignored in all CQRS analyzes
               { ... }
             }