Microsoft.CodeAnalysis.Workspaces

The annotation normally used on nodes to request case correction.

Case corrects all names found in the provided document.

Case corrects all names found in the spans of any nodes annotated with the provided annotation.

Case corrects all names found in the span.

Case corrects all names found in the provided spans.

Case correct only things that don't require semantic information

Case corrects all names found in the spans in the provided document.

Case corrects only things that don't require semantic information

Determine whether we can change the namespace for given in the document. Linked documents are not supported, except for a regular document in a multi-targeting project, where the container node must be consistent among all linked documents. Here's the additional requirements on to use this service: - If is a namespace declaration node: 1. Doesn't contain or is nested in other namespace declarations 2. The name of the namespace is valid (i.e. no errors) 3. No partial type declared in the namespace. Otherwise its multiple declarations will end up in different namespace. - If is a compilation unit node: 1. It must contain no namespace declaration 2. No partial type declared in the document. Otherwise its multiple declarations will end up in different namespace. - Otherwise, an will be thrown. Returns only when all the requirements above are met.

While this service might be used by features that change namespace based on some property of the document (e.g. Sync namespace refactoring), those logic is implemented by those individual features and isn't part of the IChangeNamespaceService service.

Change namespace for given to the name specified by . Everything declared in the will be moved to the new namespace. Change will only be made if returns and is a valid name for namespace. Use "" for to specify the global namespace. An will be thrown if: 1. is not a namespace declaration or a compilation unit node. 2. is null or contains an invalid character.

If the declared namespace for is already identical to , then it will be a no-op and original solution will be returned.

Using only the top level namespace declarations of a document, change all of them to the target namespace. Will only use namespace containers considered valid by

Helper to add all the values of into without causing any allocations or boxing of enumerators.

Additive classifications types supply additional context to other classifications.

Classifies the provided in the given . This will do this using an appropriate if that can be found. will be returned if this fails.

Whether or not 'additive' classification spans are included in the results or not. 'Additive' spans are things like 'this variable is static' or 'this variable is overwritten'. i.e. they add additional information to a previous classification.

Classifies the provided in the given . This will do this using an appropriate if that can be found. will be returned if this fails.

the current document. The non-intersecting portions of the document to get classified spans for. The options to use when getting classified spans. Whether or not 'additive' classification spans are included in the results or not. 'Additive' spans are things like 'this variable is static' or 'this variable is overwritten'. i.e. they add additional information to a previous classification. A cancellation token.

Ensures that all spans in do not go beyond the spans in . Any spans that are entirely outside of are replaced with .

Adds all semantic parts to final parts, and adds all portions of that do not overlap with any semantic parts as well. All final parts will be non-empty. Both and must be sorted.

Returns classified spans in ascending order. s may have the same . This occurs when there are multiple s for the same region of code. For example, a reference to a static method will have two spans, one that designates it as a method, and one that designates it as static. s may also have overlapping s. This occurs when there are strings containing regex and/or escape characters.

Produce the classifications for the span of text specified. Classification should be performed as quickly as possible, and should process the text in a lexical fashion. This allows classification results to be shown to the user when a file is opened before any additional compiler information is available for the text. Important: The classification should not consider the context the text exists in, and how that may affect the final classifications. This may result in incorrect classification (i.e. identifiers being classified as keywords). These incorrect results will be patched up when the lexical results are superseded by the calls to AddSyntacticClassifications.

This method is optional and only should be implemented by languages that support syntax. If the language does not support syntax, callers should use instead.

Produce the classifications for the span of text specified. The syntax of the document can be accessed to provide more correct classifications. For example, the syntax can be used to determine if a piece of text that looks like a keyword should actually be considered an identifier in its current context.

the current document. The non-intersecting portions of the document to add classified spans for. The list to add the spans to. A cancellation token.

Produce the classifications for the span of text specified. Semantics of the language can be used to provide richer information for constructs where syntax is insufficient. For example, semantic information can be used to determine if an identifier should be classified as a type, structure, or something else entirely.

the current document. The non-intersecting portions of the document to add classified spans for. The options to use when adding spans. The list to add the spans to. A cancellation token. This will not include classifications for embedded language constructs in string literals. For that use .

Produce the classifications for embedded language string literals (e.g. Regex/Json strings) in the span of text specified.

the current document. The non-intersecting portions of the document to add classified spans for. The options to use when adding spans. The list to add the spans to. A cancellation token.

Adjust a classification from a previous version of text accordingly based on the current text. For example, if a piece of text was classified as an identifier in a previous version, but a character was added that would make it into a keyword, then indicate that here. This allows the classified to quickly fix up old classifications as the user types. These adjustments are allowed to be incorrect as they will be superseded by calls to get the syntactic and semantic classifications for this version later.

Determines the range of the documents that should be considered syntactically changed after an edit. In language systems that can reuse major parts of a document after an edit, and which would not need to recompute classifications for those reused parts, this can speed up processing on a host by not requiring the host to reclassify all the source in view, but only the source that could have changed. If determining this is not possible, or potentially expensive, can be returned to indicate that the entire document should be considered changed and should be syntactically reclassified. Implementations should attempt to abide by the provided timeout as much as they can, returning the best information available at that point. As this can be called in performance critical scenarios, it is better to return quickly with potentially larger change span (including that of the full document) rather than spend too much time computing a very precise result.

This method is optional and only should be implemented by languages that support syntax. If the language does not support syntax, callers should use instead.

Gets the cached semantic classifications for the specified document and text spans.

The checksum of the solution containing the document. The ID of the document to get classified spans for. The non-intersecting portions of the document to get classified spans for. The type of classified spans to get. The options to use when getting classified spans. Whether or not the document is fully loaded. A cancellation token. The classified spans for the specified document and text spans.

Tries to get cached semantic classifications for the specified document and the specified . Will return an empty array not able to.

The key of the document to get cached classified spans for. The non-intersecting portions of the document to get cached classified spans for. The type of classified spans to get. Pass in . This will ensure that the cached classifications are only returned if they match the content the file currently has. A cancellation token. The cached classified spans for the specified document and text spans.

For space efficiency, we encode classified spans as triples of ints in one large array. The first int is the index of classification type in , and the second and third ints encode the span.

The syntax node types this classifier is able to classify. This list must be the precise node types matches (using n.GetType().Equals(t)). Subtyping type checks are not supported here.

The syntax token kinds this classifier is able to classify

This method will be called for all nodes that match the types specified by the property.

This method will be called for all tokens that match the kinds specified by the property.

Computes a syntactic text change range that determines the range of a document that was changed by an edit. The portions outside this change range are guaranteed to be syntactically identical (see ). This algorithm is intended to be fast. It is technically linear in the number of nodes and tokens that may need to examined. However, in practice, it should operate in sub-linear time as it will bail the moment tokens don't match, and it's able to skip over matching nodes fully without examining the contents of those nodes. This is intended for consumers that want a reasonably accurate change range computer, but do not want to spend an inordinate amount of time getting the most accurate and minimal result possible.

This computation is not guaranteed to be minimal. It may return a range that includes parts that are unchanged. This means it is also legal for the change range to just specify the entire file was changed. The quality of results will depend on how well the parsers did with incremental parsing, and how much time is given to do the comparison. In practice, for large files (i.e. 15kloc) with standard types of edits, this generally returns results in around 50-100 usecs on a i7 3GHz desktop. This algorithm will respect the timeout provided to the best of abilities. If any information has been computed when the timeout elapses, it will be returned.

Apply this annotation to a SyntaxNode to indicate a conflict may exist that requires user understanding and acknowledgment before taking action.

Apply this annotation to an appropriate Syntax element to request that it should be navigated to by the user after a code action is applied. If present the host should try to place the user's caret at the beginning of the element.

By using a this navigation location will be resilient to the transformations performed by the infrastructure. Namely it will be resilient to the formatting, reduction or case correction that automatically occures. This allows a code action to specify a desired location for the user caret to be placed without knowing what actual position that location will end up at when the action is finally applied.

Apply this annotation to an appropriate SyntaxNode to request that it should be renamed by the user after the action.

Apply this annotation to a SyntaxNode to indicate that a warning message should be presented to the user.

An action produced by a or a .

Special tag that indicates that it's this is a privileged code action that is allowed to use the priority class.

Tag we use to convey that this code action should only be shown if it's in a host that allows for non-document changes. For example if it needs to make project changes, or if will show host-specific UI. Note: if the bulk of code action is just document changes, and it does some optional things beyond that (like navigating the user somewhere) this should not be set. Such a code action is still usable in all hosts and should be shown to the user. It's only if the code action can truly not function should this tag be provided. Currently, this also means that we presume that all 3rd party code actions do not require non-document changes and we will show them all in all hosts.

A short title describing the action that may appear in a menu.

Two code actions are treated as equivalent if they have equal non-null values and were generated by the same or .

Equivalence of code actions affects some Visual Studio behavior. For example, if multiple equivalent code actions result from code fixes or refactorings for a single Visual Studio light bulb instance, the light bulb UI will present only one code action from each set of equivalent code actions. Additionally, a Fix All operation will apply only code actions that are equivalent to the original code action. If two code actions that could be treated as equivalent do not have equal values, Visual Studio behavior may be less helpful than would be optimal. If two code actions that should be treated as distinct have equal values, Visual Studio behavior may appear incorrect.

Priority of this particular action within a group of other actions. Less relevant actions should override this and specify a lower priority so that more important actions are easily accessible to the user. Returns if not overridden.

Computes the group this code action should be presented in. Legal values this can be must be between and .

Values outside of this range will be clamped to be within that range. Requests for may be downgraded to as they poorly behaving high-priority items can cause a negative user experience.

Descriptive tags from . These tags may influence how the item is displayed.

Child actions contained within this . Can be presented in a host to provide more potential solution actions to a particular problem. To create a with nested actions, use .

Code actions that should be presented as hyperlinks in the code action preview pane, similar to FixAll scopes and Preview Changes but may not apply to ALL CodeAction types.

Bridge method for sdk. https://github.com/dotnet/roslyn-sdk/issues/1136 tracks removing this.

If this code action contains , this property provides a hint to hosts as to whether or not it's ok to elide this code action and just present the nested actions instead. When a host already has a lot of top-level actions to show, it should consider not inlining this action, to keep the number of options presented to the user low. However, if there are few options to show to the user, inlining this action could be beneficial as it would allow the user to see and choose one of the nested options with less steps. To create a with nested actions, use .

Gets custom tags for the CodeAction.

Lazily set provider type that registered this code action. Used for telemetry purposes only.

Used by the CodeFixService and CodeRefactoringService to add the Provider Name as a CustomTag.

The sequence of operations that define the code action.

The sequence of operations used to construct a preview.

Override this method if you want to implement a subclass that includes custom 's.

Override this method if you want to implement a subclass that includes custom 's. Prefer overriding this method over when computation is long running and progress should be shown to the user.

Override this method if you want to implement a that has a set of preview operations that are different than the operations produced by .

Computes all changes for an entire solution. Override this method if you want to implement a subclass that changes more than one document. Override to report progress progress while computing the operations.

Computes all changes for an entire solution. Override this method if you want to implement a subclass that changes more than one document. Prefer overriding this method over when computation is long running and progress should be shown to the user.

Computes changes for a single document. Override this method if you want to implement a subclass that changes a single document. Override to report progress progress while computing the operations.

All code actions are expected to operate on solutions. This method is a helper to simplify the implementation of for code actions that only need to change one document. If this code action does not support changing a single document.

Computes changes for a single document. Override this method if you want to implement a subclass that changes a single document. Prefer overriding this method over when computation is long running and progress should be shown to the user.

used by batch fixer engine to get new solution

Apply post processing steps to any 's.

A list of operations. A cancellation token. A new list of operations with post processing steps applied to any 's.

Apply post processing steps to solution changes, like formatting and simplification.

The solution changed by the . A cancellation token

Apply post processing steps to a single document: Reducing nodes annotated with Formatting nodes annotated with

The document changed by the . A cancellation token. A document with the post processing changes applied.

Creates a for a change to a single . Use this factory when the change is expensive to compute and should be deferred until requested.

Title of the . Function to create the . Optional value used to determine the equivalence of the with other s. See . Code action priority

Creates a for a change to more than one within a . Use this factory when the change is expensive to compute and should be deferred until requested.

Title of the . Function to create the . Optional value used to determine the equivalence of the with other s. See .

Creates a for a change to more than one within a . Use this factory when the change is expensive to compute and should be deferred until requested.

Title of the . Function to create the . Optional value used to determine the equivalence of the with other s. See .

Creates a representing a group of code actions.

Title of the group. The code actions within the group. to allow inlining the members of the group into the parent; otherwise, to require that this group appear as a group with nested actions. Priority of the code action

Indicates if this CodeAction was created using one of the 'CodeAction.Create' factory methods. This is used in to determine the appropriate type name to log in the CodeAction telemetry.

We do cleanup in N serialized passes. This allows us to process all documents in parallel, while only forking the solution N times *total* (instead of N times *per* document).

Priority of a particular code action produced by either a or a . Code actions use priorities to group themselves, with lower priority actions showing up after higher priority ones. Providers should put less relevant code actions into lower priority buckets to have them appear later in the UI, allowing the user to get to important code actions more quickly.

Lowest priority code actions. Will show up after priority items.

Low priority code action. Will show up after priority items.

Medium priority code action.

High priority code action. Note: High priority is simply a request on the part of a . The core engine may automatically downgrade these items to priority.

Priority class that a particular or should run at. Providers are run in priority order, allowing the results of higher priority providers to be computed and shown to the user without having to wait on, or share computing resources with, lower priority providers. Providers should choose lower priority classes if they are either: Very slow. Slow providers will impede computing results for other providers in the same priority class. So running in a lower one means that fast providers can still get their results to users quickly. Less relevant. Providers that commonly show available options, but those options are less likely to be taken, should run in lower priority groups. This helps ensure their items are still there when the user wants them, but aren't as prominently shown.

Only lowest priority suppression and configuration fix providers should be run. Specifically, providers will be run. NOTE: This priority is reserved for suppression and configuration fix providers and should not be used by regular code fix providers and refactoring providers.

Run the priority below priority. The provider may run slow, or its results may be commonly less relevant for the user.

Run this provider at default priority. The provider will run in reasonable speeds and provide results that are commonly relevant to the user.

Run this provider at high priority. Note: High priority is simply a request on the part of a provider. The core engine may automatically downgrade these items to priority.

Clamps the value of (which could be any integer) to the legal range of values present in .

A that can vary with user specified options. Override one of or to actually compute the operations for this action.

Gets the options to use with this code action. This method is guaranteed to be called on the UI thread.

A cancellation token. An implementation specific object instance that holds options for applying the code action.

Gets the 's for this given the specified options.

An object instance returned from a prior call to . A cancellation token.

Override this method to compute the operations that implement this .

An object instance returned from a call to . A cancellation token.

Override this method to compute the operations that implement this . Prefer overriding this method over when computation is long running and progress should be shown to the user.

A for applying solution changes to a workspace. may return at most one . Hosts may provide custom handling for s, but if a requires custom host behavior not supported by a single , then instead: Implement a custom and s Do not return any from Directly apply any workspace edits Handle any custom host behavior Produce a preview for by creating a custom or returning a single to use the built-in preview mechanism

Represents a single operation of a multi-operation code action.

A short title describing of the effect of the operation.

Called by the host environment to apply the effect of the operation. This method is guaranteed to be called on the UI thread.

Operations may make all sorts of changes that may not be appropriate during testing (like popping up UI). So, by default, we don't apply them unless the operation asks for that to happen.

A code action operation for requesting a document be opened in the host environment.

Represents a preview operation for generating a custom user preview for the operation.

Gets a custom preview control for the operation. If preview is null and is non-null, then is used to generate the preview.

Get the proper start position based on the span marker type.

Get the proper end position based on the span marker type.

Inject annotations into the node so that it can re-calculate spans for each code cleaner after each tree transformation.

Make sure annotations are positioned outside of any spans. If not, merge two adjacent spans to one.

Retrieves four tokens around span like below. [previousToken][startToken][SPAN][endToken][nextToken]

Adjust provided span to align to either token's start position or end position.

Find closest token (including one in structured trivia) right of given position

Find closest token (including one in structured trivia) left of given position

Enum that indicates type of span marker

Normal case

Span starts at the beginning of the tree

Span ends at the end of the tree

Internal annotation type to mark span location in the tree.

Indicates the current marker type

Indicates how to find the other side of the span marker if it is missing

Static CodeCleaner class that provides default code cleaning behavior.

Return default code cleaners for a given document. This can be modified and given to the Cleanup method to provide different cleaners.

Cleans up the whole document. Optionally you can provide your own options and code cleaners. Otherwise, the default will be used.

Cleans up the document marked with the provided annotation. Optionally you can provide your own options and code cleaners. Otherwise, the default will be used.

Clean up the provided span in the document. Optionally you can provide your own options and code cleaners. Otherwise, the default will be used.

Clean up the provided spans in the document. Optionally you can provide your own options and code cleaners. Otherwise, the default will be used.

Clean up the provided span in the node. This will only cleanup stuff that doesn't require semantic information.

Clean up the provided spans in the node. This will only cleanup stuff that doesn't require semantic information.

Internal code cleanup service interface. This is not supposed to be used directly. It just provides a way to get the right service from each language.

Returns the default code cleaners.

This will run all provided code cleaners in an order that is given to the method.

This will run all provided code cleaners in an order that is given to the method. This will do cleanups that don't require any semantic information.

Specifies the exact type of the code cleanup exported.

A code cleaner that requires semantic information to do its job.

Returns the name of this provider.

This should apply its code clean up logic to the spans of the document.

This will run all provided code cleaners in an order that is given to the method. This will do cleanups that don't require any semantic information

Default implementation of a that efficiently handles the dispatch logic for fixing entire solutions. Used by and .

Helper methods for DocumentBasedFixAllProvider common to code fixes and refactorings.

An enum to distinguish if we are performing a Fix all occurences for a code fix or a code refactoring.

Fix all occurrences logging.

Contains computed information for a given , such as supported diagnostic Ids and supported .

Gets an optional for the given code fix provider or suppression fix provider.

Gets an optional for the given code fix provider.

Gets an optional for the given code refactoring provider.

Gets an optional for the given suppression fix provider.

Represents a FixAllContext for code fixes or refactorings.

Represents a FixAllProvider for code fixes or refactorings.

Represents internal FixAllState for code fixes or refactorings.

Underlying code fix provider or code refactoring provider for the fix all occurrences fix.

Language service for mapping spans for specific s for fix all occurences code fix. Every language that wants to support span based FixAll scopes, such as , , should implement this language service. Non-span based FixAll scopes, such as , and do not require such a span mapping, and this service will never be called for these scopes. This language service does not need to be implemented by languages that only intend to support these non-span based FixAll scopes.

For the given and in the given , returns the documents and fix all spans within each document that need to be fixed. Note that this API is only invoked for span based FixAll scopes, i.e. and .

Represents a single fix. This is essentially a tuple that holds on to a and the set of s that this will fix.

This is the diagnostic that will show up in the preview pane header when a particular fix is selected in the light bulb menu. We also group all fixes with the same together (into a single SuggestedActionSet) in the light bulb menu.

A given fix can fix one or more diagnostics. However, our light bulb UI (preview pane, grouping of fixes in the light bulb menu etc.) currently keeps things simple and pretends that each fix fixes a single . Implementation-wise the is always the first diagnostic that the supplied when registering the fix (). This could change in the future, if we decide to change the UI to depict the true mapping between fixes and diagnostics or if we decide to use some other heuristic to determine the .

Context for code fixes provided by a .

Document corresponding to the to fix. For code fixes that support non-source documents by providing a non-default value for , this property will throw an . Such fixers should use the property instead.

TextDocument corresponding to the to fix. This property should be used instead of property by code fixes that support non-source documents by providing a non-default value for

Text span within the or to fix.

Diagnostics to fix. NOTE: All the diagnostics in this collection have the same .

CancellationToken.

Creates a code fix context to be passed into method.

Document to fix. Text span within the to fix. Diagnostics to fix. All the diagnostics must have the same . Additionally, the of each diagnostic must be in the set of the of the associated . Delegate to register a fixing a subset of diagnostics. Cancellation token. Throws this exception if any of the arguments is null. Throws this exception if the given is empty, has a null element or has an element whose span is not equal to .

Creates a code fix context to be passed into method.

Text document to fix. Text span within the to fix. Diagnostics to fix. All the diagnostics must have the same . Additionally, the of each diagnostic must be in the set of the of the associated . Delegate to register a fixing a subset of diagnostics. Cancellation token. Throws this exception if any of the arguments is null. Throws this exception if the given is empty, has a null element or has an element whose span is not equal to .

Creates a code fix context to be passed into method.

Document to fix. Diagnostic to fix. The of this diagnostic must be in the set of the of the associated . Delegate to register a fixing a subset of diagnostics. Cancellation token. Throws this exception if any of the arguments is null.

Creates a code fix context to be passed into method.

Text document to fix. Diagnostic to fix. The of this diagnostic must be in the set of the of the associated . Delegate to register a fixing a subset of diagnostics. Cancellation token. Throws this exception if any of the arguments is null.

Add supplied to the list of fixes that will be offered to the user.

The that will be invoked to apply the fix. The subset of being addressed / fixed by the .

Add supplied to the list of fixes that will be offered to the user.

The that will be invoked to apply the fix. The subset of being addressed / fixed by the .

Add supplied to the list of fixes that will be offered to the user.

The that will be invoked to apply the fix. The subset of being addressed / fixed by the .

Implement this type to provide fixes for source code problems. Remember to use so the host environment can offer your fixes in a UI.

A list of diagnostic IDs that this provider can provide fixes for.

Computes one or more fixes for the specified .

A containing context information about the diagnostics to fix. The context must only contain diagnostics with a included in the for the current provider.

Gets an optional that can fix all/multiple occurrences of diagnostics fixed by this code fix provider. Return null if the provider doesn't support fix all/multiple occurrences. Otherwise, you can return any of the well known fix all providers from or implement your own fix all provider.

Computes the group this provider should be considered to run at. Legal values this can be must be between and .

Values outside of this range will be clamped to be within that range. Requests for may be downgraded to as they poorly behaving high-priority providers can cause a negative user experience.

Priority class this refactoring provider should run at. Returns if not overridden. Slower, or less relevant, providers should override this and return a lower value to not interfere with computation of normal priority providers.

Use this attribute to declare a implementation so that it can be discovered by the host.

Optional name of the .

The source languages this provider can provide fixes for. See .

The document kinds for which this provider can provide code fixes. See . By default, the provider supports code fixes only for source documents, . Provide string representation of the documents kinds for this property, for example: DocumentKinds = new[] { nameof(TextDocumentKind.AdditionalDocument) }

The document extensions for which this provider can provide code fixes. Each extension string must include the leading period, for example, ".txt", ".xaml", ".editorconfig", etc. By default, this value is null and the document extension is not considered to determine applicability of code fixes.

Attribute constructor used to specify automatic application of a code fix provider.

One language to which the code fix provider applies. Additional languages to which the code fix provider applies. See .

Helper class for "Fix all occurrences" code fix providers.

Returns all the changed documents produced by fixing the list of provided . The documents will be returned such that fixed documents for a later diagnostic will appear later than those for an earlier diagnostic.

Take all the changes made to a particular document and determine the text changes caused by each one. Take those individual text changes and attempt to merge them together in order into .

Provides a base class to write a that fixes documents independently. This type should be used instead of in the case where fixes for a only affect the the diagnostic was produced in.

This type provides suitable logic for fixing large solutions in an efficient manner. Projects are serially processed, with all the documents in the project being processed in parallel. Diagnostics are computed for the project and then appropriately bucketed by document. These are then passed to for implementors to process.

Provides a base class to write a that fixes documents independently. This type should be used instead of in the case where fixes for a only affect the the diagnostic was produced in.

Produce a suitable title for the fix-all this type creates in . Override this if customizing that title is desired.

Fix all the present in . The document returned will only be examined for its content (e.g. it's or . No other aspects of (like it's properties), or changes to the or it points at will be considered.

The context for the Fix All operation. The document to fix. The diagnostics to fix in the document. The new representing the content fixed document. -or- , if no changes were made to the document.

Context for "Fix all occurrences" code fixes provided by a .

Solution to fix all occurrences.

Project within which fix all occurrences was triggered.

Document within which fix all occurrences was triggered, null if the is scoped to a project.

Underlying which triggered this fix all.

to fix all occurrences.

Diagnostic Ids to fix. Note that , and methods return only diagnostics whose IDs are contained in this set of Ids.

The value expected of a participating in this fix all.

CancellationToken for fix all session.

Progress sink for reporting the progress of a fix-all operation.

Creates a new . Use this overload when applying fix all to a diagnostic with a source location. This overload cannot be used with or value for the . For those fix all scopes, use the constructor that takes a 'diagnosticSpan' parameter to identify the containing member or type based on this span.

Document within which fix all occurrences was triggered. Underlying which triggered this fix all. to fix all occurrences. The value expected of a participating in this fix all. Diagnostic Ids to fix. to fetch document/project diagnostics to fix in a . Cancellation token for fix all computation.

Creates a new with an associated . Use this overload when applying fix all to a diagnostic with a source location and using or for the . When using other fix all scopes, is not required and other constructor which does not take a diagnostic span can be used instead.

Document within which fix all occurrences was triggered. Span for the diagnostic for which fix all occurrences was triggered. Underlying which triggered this fix all. to fix all occurrences. The value expected of a participating in this fix all. Diagnostic Ids to fix. to fetch document/project diagnostics to fix in a . Cancellation token for fix all computation.

Creates a new . Use this overload when applying fix all to a diagnostic with no source location, i.e. .

Project within which fix all occurrences was triggered. Underlying which triggered this fix all. to fix all occurrences. The value expected of a participating in this fix all. Diagnostic Ids to fix. to fetch document/project diagnostics to fix in a . Cancellation token for fix all computation.

Gets all the diagnostics in the given document filtered by .

Gets all the diagnostics in the given for the given filtered by .

Gets all the project-level diagnostics, i.e. diagnostics with no source location, in the given project filtered by .

Gets all the diagnostics in the given project filtered by . This includes both document-level diagnostics for all documents in the given project and project-level diagnostics, i.e. diagnostics with no source location, in the given project.

Gets all the project diagnostics in the given project filtered by . If is false, then returns only project-level diagnostics which have no source location. Otherwise, returns all diagnostics in the project, including the document diagnostics for all documents in the given project.

Gets a new with the given cancellationToken.

Diagnostic provider to fetch document/project diagnostics to fix in a .

Gets all the diagnostics to fix in the given document in a .

Gets all the project-level diagnostics to fix, i.e. diagnostics with no source location, in the given project in a .

Gets all the diagnostics to fix in the given project in a . This includes both document-level diagnostics for all documents in the given project and project-level diagnostics, i.e. diagnostics with no source location, in the given project.

Diagnostic provider to fetch document/project diagnostics to fix in a , which supports a method to compute diagnostics for a given span within a document. We need to compute diagnostics for a span when applying a fix all operation in and scopes. A regular will compute diagnostics for the entire document and filter out diagnostics outside the span as a post-filtering step. A can do this more efficiently by implementing the method to compute the diagnostics only for the given 'fixAllSpan' upfront.

Gets all the diagnostics to fix for the given in the given in a .

Implement this abstract type to provide fix all/multiple occurrences code fixes for source code problems. Alternatively, you can use any of the well known fix all providers from .

Gets the supported scopes for fixing all occurrences of a diagnostic. By default, it returns the following scopes: (a) (b) and (c)

Gets the diagnostic IDs for which fix all occurrences is supported. By default, it returns for the given .

Original code fix provider that returned this fix all provider from method.

Gets fix all occurrences fix for the given fixAllContext.

Create a that fixes documents independently. This should be used instead of in the case where fixes for a only affect the the diagnostic was produced in.

Create a that fixes documents independently for the given . This should be used instead of in the case where fixes for a only affect the the diagnostic was produced in.

Callback that will the fix diagnostics present in the provided document. The document returned will only be examined for its content (e.g. it's or . No other aspects of it (like attributes), or changes to the or it points at will be considered. Supported s for the fix all provider. Note that is not supported by the and should not be part of the supported scopes.

Indicates scope for "Fix all occurrences" code fixes provided by each .

Scope to fix all occurences of diagnostic(s) in the entire document.

Scope to fix all occurences of diagnostic(s) in the entire project.

Scope to fix all occurences of diagnostic(s) in the entire solution.

Custom scope to fix all occurences of diagnostic(s). This scope can be used by custom s and custom code fix engines.

Scope to fix all occurrences of diagnostic(s) in the containing member relative to the trigger span for the original code fix.

Scope to fix all occurrences of diagnostic(s) in the containing type relative to the trigger span for the original code fix.

Diagnostic provider to fetch document/project diagnostics to fix in a .

A dummy fix all provider to represent a no-change provider. This is only used by public constructors for , our internal code fix engine always creates a FixAllContext with a non-null FixAllProvider. Using a for the public constructors helps us to avoid a nullable .

Helper to merge many disparate text changes to a single document together into a total set of changes.

Try to merge the changes made to into the tracked changes. If there is any conflicting change in with existing changes, then no changes are added.

Try to merge the changes made to all the documents in in order into the tracked changes. If there is any conflicting changes with existing changes for a particular document, then no changes will be added for it.

Contains well known implementations of .

Default batch fix all provider. This provider batches all the individual diagnostic fixes across the scope of fix all action, computes fixes in parallel and then merges all the non-conflicting fixes into a single fix all code action. This fixer supports fixes for the following fix all scopes: , , and .

The batch fix all provider only batches operations (i.e. ) of type present within the individual diagnostic fixes. Other types of operations present within these fixes are ignored.

Provides suppression or configuration code fixes.

Returns true if the given diagnostic can be configured, suppressed or unsuppressed by this provider.

Gets one or more add suppression, remove suppression, or configuration fixes for the specified diagnostics represented as a list of 's.

A list of zero or more potential 'es. It is also safe to return null if there are none.

Gets one or more add suppression, remove suppression, or configuration fixes for the specified no-location diagnostics represented as a list of 's.

A list of zero or more potential 'es. It is also safe to return null if there are none.

Gets an optional that can fix all/multiple occurrences of diagnostics fixed by this fix provider. Return null if the provider doesn't support fix all/multiple occurrences. Otherwise, you can return any of the well known fix all providers from or implement your own fix all provider.

Helper type for s that need to provide 'fix all' support in a document, by operate by applying one fix at a time, then recomputing the work to do after that fix is applied. While this is not generally desirable from a performance perspective (due to the costs of forking a document after each fix), it is sometimes necessary as individual fixes can impact the code so substantially that successive fixes may no longer apply, or may have dramatically different data to work with before the fix. For example, if one fix removes statements entirely that another fix was contained in.

Subclasses must override this to actually provide the fix for a particular diagnostic. The implementation will be passed the current (containing the changes from all prior fixes), the the in that document, for the current diagnostic being fixed. And the for that diagnostic. The diagnostic itself is not passed along as it was computed with respect to the original user document, and as such its and will not be correct.

Use this helper to register multiple fixes () each of which addresses / fixes the same supplied .

Use this helper to register multiple fixes () each of which addresses / fixes the same set of supplied .

Fixes all in the specified . The fixes are applied to the 's syntax tree via . The implementation may query options of any document in the 's solution.

Whether or not this diagnostic should be included when performing a FixAll. This is useful for providers that create multiple diagnostics for the same issue (For example, one main diagnostic and multiple 'faded out code' diagnostics). FixAll can be invoked from any of those, but we'll only want perform an edit for only one diagnostic for each of those sets of diagnostics. This overload differs from in that it also passes along the in case that would be useful (for example if the is used. Only one of these two overloads needs to be overridden if you want to customize behavior.

Whether or not this diagnostic should be included when performing a FixAll. This is useful for providers that create multiple diagnostics for the same issue (For example, one main diagnostic and multiple 'faded out code' diagnostics). FixAll can be invoked from any of those, but we'll only want perform an edit for only one diagnostic for each of those sets of diagnostics. By default, all diagnostics will be included in fix-all unless they are filtered out here. If only the diagnostic needs to be queried to make this determination, only this overload needs to be overridden. However, if information from is needed (for example ), then should be overridden instead. Only one of these two overloads needs to be overridden if you want to customize behavior.

Context for code refactorings provided by a .

Document corresponding to the to refactor. For code refactorings that support non-source documents by providing a non-default value for , this property will throw an . Such refactorings should use the property instead.

TextDocument corresponding to the to refactor. This property should be used instead of property by code refactorings that support non-source documents by providing a non-default value for

Text span within the or to refactor.

CancellationToken.

Creates a code refactoring context to be passed into method.

Add supplied to the list of refactorings that will be offered to the user.

The that will be invoked to apply the refactoring.

Add supplied applicable to to the list of refactorings that will be offered to the user.

The that will be invoked to apply the refactoring. The within original document the is applicable to. should represent a logical section within the original document that the is applicable to. It doesn't have to precisely represent the exact that will get changed.

Most refactorings will have the kind. This allows us to draw attention to Extract and Inline refactorings.

When new values are added here we should account for them in the `CodeActionHelpers` class.

Inherit this type to provide source code refactorings. Remember to use so the host environment can offer your refactorings in a UI.

Computes one or more refactorings for the specified .

Gets an optional that can apply multiple occurrences of code refactoring(s) registered by this code refactoring provider across the supported s. Return null if the provider doesn't support fix all operation.

Gets the indicating what kind of refactoring it is.

Computes the group this provider should be considered to run at. Legal values this can be must be between and .

Values outside of this range will be clamped to be within that range. Requests for may be downgraded to as they poorly behaving high-priority providers can cause a negative user experience.

Use this attribute to declare a implementation so that it can be discovered by the host.

The name of the .

The source languages for which this provider can provide refactorings. See .

The document kinds for which this provider can provide refactorings. See . By default, the provider supports refactorings only for source documents, .

The document extensions for which this provider can provide refactorings. Each extension string must include the leading period, for example, ".txt", ".xaml", ".editorconfig", etc. By default, this value is null and the document extension is not considered to determine applicability of refactorings.

Attribute constructor used to specify availability of a code refactoring provider.

One language to which the code refactoring provider applies. Additional languages to which the code refactoring provider applies. See .

Provides a base class to write a for refactorings that fixes documents independently. This type should be used in the case where the code refactoring(s) only affect individual s.

This type provides suitable logic for fixing large solutions in an efficient manner. Projects are serially processed, with all the documents in the project being processed in parallel. is invoked for each document for implementors to process. TODO: Make public, tracked with https://github.com/dotnet/roslyn/issues/60703

Provides a base class to write a for refactorings that fixes documents independently. This type should be used in the case where the code refactoring(s) only affect individual s.

This type provides suitable logic for fixing large solutions in an efficient manner. Projects are serially processed, with all the documents in the project being processed in parallel. is invoked for each document for implementors to process. TODO: Make public, tracked with https://github.com/dotnet/roslyn/issues/60703

Produce a suitable title for the fix-all this type creates in . Override this if customizing that title is desired.

Apply fix all operation for the code refactoring in the for the given . The document returned will only be examined for its content (e.g. it's or . No other aspects of document (like it's properties), or changes to the or it points at will be considered.

The context for the Fix All operation. The document to fix. The spans to fix in the document. If not specified, entire document needs to be fixedd. The new representing the content fixed document. -or- , if no changes were made to the document.

Attempts to apply fix all operations returning, for each updated document, either the new syntax root for that document or its new text. Syntax roots are returned for documents that support them, and are used to perform a final cleanup pass for formatting/simplification/etc. Text is returned for documents that don't support syntax.

Context for "Fix all occurrences" for code refactorings provided by each .

TODO: Make public, tracked with https://github.com/dotnet/roslyn/issues/60703

Document within which fix all occurrences was triggered.

Underlying which triggered this fix all.

to fix all occurrences.

The value expected of a participating in this fix all.

CancellationToken for fix all session.

Project to fix all occurrences. Note that this property will always be the containing project of for publicly exposed FixAllContext instance. However, we might create an intermediate FixAllContext with null and non-null Project, so we require this internal property for intermediate computation.

Gets the spans to fix by document for the for this fix all occurences fix. If no spans are specified, it indicates the entire document needs to be fixed.

Implement this abstract type to provide fix all occurrences support for code refactorings.

TODO: Make public, tracked with https://github.com/dotnet/roslyn/issues/60703

Gets the supported scopes for applying multiple occurrences of a code refactoring. By default, it returns the following scopes: (a) (b) and (c)

Gets fix all occurrences fix for the given fixAllContext.

Create a that fixes documents independently. This can be used in the case where refactoring(s) registered by this provider only affect a single .

Callback that will apply the refactorings present in the provided document. The document returned will only be examined for its content (e.g. it's or . No other aspects of it (like attributes), or changes to the or it points at will be considered. Supported s for the fix all provider. Note that is not supported by the and should not be part of the supported scopes.

Original selection span from which FixAll was invoked. This is used in to compute fix all spans for and scopes.

Gets the spans to fix by document for the for this fix all occurences fix. If no spans are specified, it indicates the entire document needs to be fixed.

Extractor function that retrieves all nodes that should be considered for extraction of given current node. The rationale is that when user selects e.g. entire local declaration statement [|var a = b;|] it is reasonable to provide refactoring for `b` node. Similarly for other types of refactorings.

Should also return given node.

Extractor function that checks and retrieves all nodes current location is in a header.

Contains helpers related to asking intuitive semantic questions about a users intent based on the position of their caret or span of their selection.

True if the user is on a blank line where a member could go inside a type declaration. This will be between members and not ever inside a member.

Returns an array of instances for refactoring given specified selection in document. determines if the returned nodes will can have empty spans or not. A instance is returned if: - Selection is zero-width and inside/touching a Token with direct parent of type . - Selection is zero-width and touching a Token whose ancestor of type ends/starts precisely on current selection. - Selection is zero-width and in whitespace that corresponds to a Token whose direct ancestor is of type of type . - Selection is zero-width and in a header (defined by ISyntaxFacts helpers) of an node of type of type . - Token whose direct parent of type is selected. - Selection is zero-width and wanted node is an expression / argument with selection within such syntax node (arbitrarily deep) on its first line. - Whole node of a type is selected. Attempts extracting a Node of type for each Node it considers (see above). E.g. extracts initializer expressions from declarations and assignments, Property declaration from any header node, etc. Note: this function trims all whitespace from both the beginning and the end of given . The trimmed version is then used to determine relevant . It also handles incomplete selections of tokens gracefully. Over-selection containing leading comments is also handled correctly.

Public representation of a code style option value. Should only be used for public API. Internally the value is represented by .

Represents a code style option and an associated notification option. Supports being instantiated with T as a or an enum type. CodeStyleOption also has some basic support for migration a option forward to an enum type option. Specifically, if a previously serialized bool-CodeStyleOption is then deserialized into an enum-CodeStyleOption then 'false' values will be migrated to have the 0-value of the enum, and 'true' values will be migrated to have the 1-value of the enum. Similarly, enum-type code options will serialize out in a way that is compatible with hosts that expect the value to be a boolean. Specifically, if the enum value is 0 or 1 then those values will write back as false/true.

Name for the notification option.

Offers different notification styles for enforcing a code style. Under the hood, it simply maps to

Notification option to disable or suppress an option with .

Notification option for a silent or hidden option with .

Notification option for a suggestion or an info option with .

Notification option for a warning option with .

Notification option for an error option with .

Given an editor-config code-style-option, gives back the core value part of the option. For example, if the option is "true:error" or "true" then "true" will be returned in .

Given an editor-config code-style-option, gives back the constituent parts of the option. For example, if the option is "true:error" then "true" will be returned in and will be returned in . Note that users are allowed to not provide a NotificationOption, so will default to .

Internal representation of a code style option value. Should be used throughout Roslyn. The internal values are translated to the public ones (ICodeStyleOption) at the public entry points.

Creates a new from a specified .

The type of the serialized data does not match the type of or the format of the serialized data is invalid. When user preferences are not yet set for a style, we fall back to the default value. One such default(s), is that the feature is turned on, so that codegen consumes it, but with silent enforcement, so that the user is not prompted about their usage.

Use singletons for most common values.

This option says if we should simplify away the . or . in field access expressions.

This option says if we should simplify away the . or . in property access expressions.

This option says if we should simplify away the . or . in method access expressions.

This option says if we should simplify away the . or . in event access expressions.

This option says if we should prefer keyword for Intrinsic Predefined Types in Declarations

This option says if we should prefer keyword for Intrinsic Predefined Types in Member Access Expression

Options that we expect the user to set in editorconfig.

Note: the order of this enum is important. We originally only supported two values, and we encoded this as a bool with 'true = WhenPossible' and 'false = never'. To preserve compatibility we map the false value to 0 and the true value to 1. All new values go after these.

Preferences if a foreach statement is allowed to have an explicit cast not visible in source.

Hidden explicit casts are not allowed. In any location where one might be emitted, users must supply their own explicit cast to make it apparent that the code may fail at runtime.

Hidden casts are allowed on legacy APIs but not allowed on strongly-typed modern APIs. An API is considered legacy if enumerating it would produce values of type or itself does not implement . These represent APIs that existed prior to the widespread adoption of generics and are the reason the language allowed this explicit conversion to not be stated for convenience. With generics though it is more likely that an explicit cast emitted is an error and the user put in an incorrect type errantly and would benefit from an alert about the issue.

Prefer namespace N { }

Prefer namespace N;

Preferences for flagging unused parameters.

Assignment preference for unused values from expression statements and assignments.

This option describes the naming rules that should be applied to specified categories of symbols, and the level to which those rules should be enforced.

Options that we expect the user to set in editorconfig.

enum for each analysis kind.

Provides and caches information about diagnostic analyzers such as , instance, s. Thread-safe.

Supported descriptors of each .

Holds on instances weakly so that we don't keep analyzers coming from package references alive. They need to be released when the project stops referencing the analyzer. The purpose of this map is to avoid multiple calls to that might return different values (they should not but we need a guarantee to function correctly).

Supported suppressions of each .

Holds on instances weakly so that we don't keep suppressors coming from package references alive. They need to be released when the project stops referencing the suppressor. The purpose of this map is to avoid multiple calls to that might return different values (they should not but we need a guarantee to function correctly).

Lazily populated map from diagnostic IDs to diagnostic descriptor. If same diagnostic ID is reported by multiple descriptors, a null value is stored in the map for that ID.

Returns of given .

Returns of given that are not compilation end descriptors.

Returns of given that are compilation end descriptors.

Returns true if given has a compilation end descriptor that is reported in the Compilation end action.

Determine whether collection of telemetry is allowed for given .

Language name () or null if the diagnostic is not associated with source code.

Properties for a diagnostic generated by an explicit build.

Create a host/VS specific diagnostic with the given descriptor and message arguments for the given project. Note that diagnostic created through this API cannot be suppressed with in-source suppression due to performance reasons (see the PERF remark below for details).

Returns true if the diagnostic was generated by an explicit build, not live analysis.

Path to where the diagnostic was originally reported. May be a path to a document in a project, or the project file itself. This should only be used by clients that truly need to know the original location a diagnostic was reported at, ignoring things like #line directives or other systems that would map the diagnostic to a different file or location. Most clients should instead use , which contains the final location (file and span) that the diagnostic should be considered at.

Document the diagnostic is associated with. May be null if this is a project diagnostic.

Path and span where the diagnostic has been finally mapped to. If no mapping happened, this will be equal to . The of this value will be the fully normalized file path where the diagnostic is located at.

Return a new location with the same as this, but with updated and corresponding to the respection locations of within .

Scope for analyzing a document for computing local syntax/semantic diagnostics.

Gets the corresponding to the . NOTE: Throws an exception if is not an .

IDE-only document based diagnostic analyzer.

it is not allowed one to implement both DocumentDiagnosticAnalzyer and DiagnosticAnalyzer

This lets vsix installed or to specify priority of the analyzer. Regular always comes before those 2 different types. Priority is ascending order and this only works on HostDiagnosticAnalyzer meaning Vsix installed analyzers in VS. This is to support partner teams (such as typescript and F#) who want to order their analyzer's execution order.

Cache of a to its . We cache this as the latter computes and allocates expensively every time it is called.

Filters out the diagnostics with the specified . If is non-null, filters out diagnostics with location outside this span.

Calculates a checksum that contains a project's checksum along with a checksum for each of the project's transitive dependencies.

This checksum calculation can be used for cases where a feature needs to know if the semantics in this project changed. For example, for diagnostics or caching computed semantic data. The goal is to ensure that changes to Files inside the current project Project properties of the current project Visible files in referenced projects Project properties in referenced projects are reflected in the metadata we keep so that comparing solutions accurately tells us when we need to recompute semantic work. This method of checking for changes has a few important properties that differentiate it from other methods of determining project version. Changes to methods inside the current project will be reflected to compute updated diagnostics. does not change as it only returns top level changes. Reloading a project without making any changes will re-use cached diagnostics. changes as the project is removed, then added resulting in a version change. This checksum is also affected by the for this project. As such, it is not usable across different sessions of a particular host.

A dummy singleton analyzer. Its only purpose is to represent file content load failures in maps that are keyed by .

A placeholder singleton analyzer. Its only purpose is to represent generator-produced diagnostics in maps that are keyed by .

Key is . We use the key to de-duplicate analyzer references if they are referenced from multiple places.

Key is the language the supports and key for the second map is analyzer reference identity and for that assembly reference. Entry will be lazily filled in.

Key is . Value is set of that belong to the . We populate it lazily. otherwise, we will bring in all analyzers preemptively

Maps to compiler diagnostic analyzers.

Maps list of analyzer references and to .

TODO: https://github.com/dotnet/roslyn/issues/42848 It is quite common for multiple projects to have the same set of analyzer references, yet we will create multiple instances of the analyzer list and thus not share the info.

List of host s

Get identity and s map for given

Create identity and s map for given that includes both host and project analyzers

Create identity and s map for given that has only project analyzers

Return compiler for the given language.

Given the original location of the diagnostic and the mapped line info based on line directives in source, apply any necessary adjustments to these diagnostic spans and returns the effective source span for the diagnostic. For example, for Venus, we might change the mapped location to be the location in the primary buffer. Additionally, if the secondary buffer location is outside visible user code, then the original location is also adjusted to be within visible user code.

IDE-only project based diagnostic analyzer.

it is not allowed one to implement both ProjectDiagnosticAnalzyer and DiagnosticAnalyzer

Information about analyzers supplied by the host (IDE), which can be completely skipped or its diagnostics partially filtered for the corresponding project as project analyzer reference (from NuGet) has equivalent analyzer(s) reporting all or subset of diagnostic IDs reported by these analyzers.

Analyzers supplied by the host (IDE), which can be completely skipped for the corresponding project as project analyzer reference has equivalent analyzer(s) reporting all diagnostic IDs reported by these analyzers.

Analyzer to diagnostic ID map, such that the diagnostics of those IDs reported by the analyzer should be filtered for a correspndiong project. This includes the analyzers supplied by the host (IDE), such that project's analyzer references (from NuGet) has equivalent analyzer(s) reporting subset of diagnostic IDs reported by these analyzers.

Predefined name of diagnostic property which shows in what compilation stage the diagnostic is created.

An implementation of for the compiler that wraps a .

Create a from a .

An implementation of for the compiler that wraps a .

Create a from a .

Resolved path of the document.

Retrieves a with the contents of this file.

that memoize structured (parsed) form of certain complex options to avoid parsing them multiple times. Storages of these complex options may directly call the specialized getters to reuse the cached values.

Returns the equivalent for a value.

The value. The equivalent for the value. If is not one of the expected values.

Returns the equivalent for a value.

The value. The equivalent for a value; otherwise, if does not contain a direct equivalent for . If is not one of the expected values.

Applies a default severity to a value.

The value. The default severity. If is , returns . -or- Otherwise, returns if it has a non-default value.

Each word is capitalized

Every word except the first word is capitalized

Only the first word is capitalized

Every character is capitalized

No characters are capitalized

Determines if matches a subset of the symbols matched by . The implementation determines which properties of are considered for this evaluation. The subset relation does not necessarily indicate a proper subset.

The first naming rule. The second naming rule. if matches a subset of the symbols matched by on some implementation-defined properties; otherwise, .

This does not handle the case where a method in a base type implicitly implements an interface method on behalf of one of its derived types.

Contains all information related to Naming Style Preferences. 1. Symbol Specifications 2. Name Style 3. Naming Rule (points to Symbol Specification IDs)

Invalid value, analyzer must support at least one or more of the subsequent analysis categories.

Analyzer reports syntax diagnostics (i.e. registers a SyntaxTree action). Note: an that uses this will not work properly if it registers a and then ends up needing to use the . If a is needed, use or .

Analyzer reports semantic diagnostics and also supports incremental span based method body analysis. An analyzer can support incremental method body analysis if edits within a method body only affect the diagnostics reported by the analyzer on the edited method body.

Analyzer reports semantic diagnostics but doesn't support incremental span based method body analysis. It needs to re-analyze the whole document for reporting semantic diagnostics even for method body editing scenarios.

This interface is a marker for all the analyzers that are built in. We will record non-fatal-watson if any analyzer with this interface throws an exception. also, built in analyzer can do things that third-party analyzer (command line analyzer) can't do such as reporting all diagnostic descriptors as hidden when it can return different severity on runtime. or reporting diagnostics ID that is not reported by SupportedDiagnostics. this interface is used by the engine to allow this special behavior over command line analyzers.

This category will be used to run analyzer more efficiently by restricting scope of analysis

If this analyzer is privileged and should run with higher priority than other analyzers.

Special IDE analyzer to flag unnecessary inline source suppressions, i.e. pragma and local SuppressMessageAttribute suppressions.

Analyzes the tree, with an optional span scope, and report unnecessary inline suppressions.

This holds onto diagnostics for a specific version of project snapshot in a way each kind of diagnostics can be queried fast.

The set of documents that has any kind of diagnostics on it.

Syntax diagnostics from this file.

Semantic diagnostics from this file.

Diagnostics that were produced for these documents, but came from the analysis of other files.

Diagnostics that don't have locations.

We have this builder to avoid creating collections unnecessarily. Expectation is that, most of time, most of analyzers doesn't have any diagnostics. so no need to actually create any objects.

Basically typed tuple.

Any MEF component implementing this interface will be used to redirect analyzer assemblies.

The redirected path is passed to the compiler where it is processed in the standard way, e.g., the redirected assembly is shadow copied before it's loaded (this could be improved in the future since shadow copying redirected assemblies is usually unnecessary). Original full path of the analyzer assembly. The redirected full path of the analyzer assembly or if this instance cannot redirect the given assembly. If two redirectors return different paths for the same assembly, no redirection will be performed. No thread switching inside this method is allowed.

An interface implemented by hosts to provide the host-level analyzers; for example in Visual Studio for Windows this is where we'll fetch VSIX-defined analyzers.

Gets the path to any assemblies that represent the closure of razor compiler.

Helper class to manage collections of source-file like things; this exists just to avoid duplicating all the logic for regular source files and additional files.

This class should be free-threaded, and any synchronization is done via . This class is otherwise free to operate on private members of if needed.

The map of file paths to the underlying . This document may exist in or has been pushed to the actual workspace.

A map of explicitly-added "always open" and their associated . This does not contain any regular files that have been open.

The map of to whose got added into

The current list of documents that are to be added in this batch.

The current list of documents that are being removed in this batch. Once the document is in this list, it is no longer in .

The current list of document file paths that will be ordered in a batch.

Process file content changes

filepath given from project system filepath used in workspace. it might be different than projectSystemFilePath

Updates the solution for a set of batch changes. While it is OK for this method to *read* local state, it cannot *modify* it as this may be called multiple times (when the workspace update fails due to interceding updates).

A semaphore taken for all mutation of any mutable field in this type.

This is, for now, intentionally pessimistic. There are no doubt ways that we could allow more to run in parallel, but the current tradeoff is for simplicity of code and "obvious correctness" than something that is subtle, fast, and wrong.

The number of active batch scopes. If this is zero, we are not batching, non-zero means we are batching.

The set of actual analyzer reference paths that the project knows about.

The set of SDK code style analyzer reference paths that the project knows about.

Paths to analyzers we want to add when the current batch completes.

Paths to analzyers we want to remove when the current batch completes.

If this project is the 'primary' project the project system cares about for a group of Roslyn projects that correspond to different configurations of a single project system project. by default.

The full list of all metadata references this project has. References that have internally been converted to project references will still be in this.

The file watching tokens for the documents in this project. We get the tokens even when we're in a batch, so the files here may not be in the actual workspace yet.

A file change context used to watch source files, additional files, and analyzer config files for this project. It's automatically set to watch the user's project directory so we avoid file-by-file watching.

track whether we have been subscribed to event

Map of the original dynamic file path to the that was associated with it. For example, the key is something like Page.cshtml which is given to us from the project system calling . The value of the map is a generated file that corresponds to the original path, say Page.g.cs. If we were given a file by the project system but no provided a file for it, we will record the value as null so we still can track the addition of the .cshtml file for a later call to . The workspace snapshot will only have a document with (the value) but not the original dynamic file path (the key).

We use the same string comparer as in the used by _sourceFiles, below, as these files are added to that collection too.

Reports a telemetry event if compilation information is being thrown away after being previously computed

The path to the output in obj.

The path to the source generated files.

The default namespace of the project.

In C#, this is defined as the value of "rootnamespace" msbuild property. Right now VB doesn't have the concept of "default namespace", but we conjure one in workspace by assigning the value of the project's root namespace to it. So various features can choose to use it for their own purpose. In the future, we might consider officially exposing "default namespace" for VB project (e.g.through a "defaultnamespace" msbuild property)

The max language version supported for this project, if applicable. Useful to help indicate what language version features should be suggested to a user, as well as if they can be upgraded.

Flag to control if this has already been disposed. Not a boolean only so it can be used with Interlocked.CompareExchange.

Adds a source file to the project from a text container (eg, a Visual Studio Text buffer)

The text container that contains this file. The file path of the document. The kind of the source code. The names of the logical nested folders the document is contained in. Whether the document is used only for design time (eg. completion) or also included in a compilation. A associated with this document

Returns the properties being used for the current metadata reference added to this project. May return multiple properties if the reference has been added multiple times with different properties.

Clears a list and zeros out the capacity. The lists we use for batching are likely to get large during an initial load, but after that point should never get that large again.

The main gate to synchronize updates to this solution.

See the Readme.md in this directory for further comments about threading in this area.

Stores the latest state of the project system factory. Access to this is synchronized via

A set of documents that were added by , and aren't otherwise tracked for opening/closing.

Should be updated with . Should be updated with .

Set by the host if the solution is currently closing; this can be used to optimize some things there.

The current path to the solution. Currently this is only used to update the solution path when the first project is added -- we don't have a concept of the solution path changing in the middle while a bunch of projects are loaded.

Applies a single operation to the workspace. should be a call to one of the protected Workspace.On* methods.

Applies a single operation to the workspace that also needs to update the . should be a call to one of the protected Workspace.On* methods.

Applies a solution transformation to the workspace and triggers workspace changed event for specified . The transformation shall only update the project of the solution with the specified . The function must be safe to be attempted multiple times (and not update local state).

Applies a change to the workspace that can do any number of project changes. The mutation action must be safe to attempt multiple times, in case there are interceding solution changes. If outside changes need to run under the global lock and run only once, they should use the action. will always run even if the transformation applied no changes.

This is needed to synchronize with to avoid any races. This method could be moved down to the core Workspace layer and then could use the synchronization lock there.

Removes the project from the various maps this type maintains; it's still up to the caller to actually remove the project in one way or another.

Attempts to convert all metadata references to to a project reference to .

The of the project that could be referenced in place of the output path. The output path to replace.

Finds all projects that had a project reference to and convert it back to a metadata reference.

The of the project being referenced. The output path of the given project to remove the link to.

Converts a metadata reference to a project reference if possible. This must be safe to run multiple times for the same reference as it is called during a workspace update (which will attempt to apply the update multiple times).

Tries to convert a metadata reference to remove to a project reference.

Gets or creates a PortableExecutableReference instance for the given file path and properties. Calls to this are expected to be serialized by the caller.

Core helper that handles refreshing the references we have for a particular or .

Immutable data type that holds the current state of the project system factory as well as storing any incremental state changes in the current workspace update. This state is updated by various project system update operations under the . Importantly, this immutable type allows us to discard updates to the state that fail to apply due to interceding workspace operations. There are two kinds of state that this type holds that need to support discarding: Global state for the (various maps of project information). This state must be saved between different changes. Incremental state for the current change being processed. This state has information that is cannot be resilient to being applied multiple times during the workspace update, so is saved to be applied only once the workspace update is successful.

Global state representing a multimap from an output path to the project outputting to it. Ideally, this shouldn't ever actually be a true multimap, since we shouldn't have two projects outputting to the same path, but any bug by a project adding the wrong output path means we could end up with some duplication. In that case, we'll temporarily have two until (hopefully) somebody removes it. Global state containing output paths and converted project reference information for each project. Incremental state containing metadata references removed in the current update. Incremental state containing metadata references added in the current update. Incremental state containing analyzer references removed in the current update. Incremental state containing analyzer references added in the current update.

Global state containing output paths and converted project reference information for each project.

Incremental state containing metadata references removed in the current update.

Incremental state containing metadata references added in the current update.

Incremental state containing analyzer references removed in the current update.

Incremental state containing analyzer references added in the current update.

Returns a new instance with any incremental state that should not be saved between updates cleared.

Gate to guard all mutable fields in this class. The lock hierarchy means you are allowed to call out of this class and into while holding the lock.

A hashed checksum of the last command line we were set to. We use this as a low cost (in terms of memory) way to determine if the command line actually changes and we need to make any downstream updates.

To save space in the managed heap, we dump the entire command-line string to our temp-storage-service. This is helpful as compiler command-lines can grow extremely large (especially in cases with many references).

Note: this will be null in the case that the command line is an empty array. if the command line was updated.

Returns the active path to the rule set file that is being used by this project, or null if there isn't a rule set file.

Returns the parsed command line arguments for the arguments set with .

Overridden by derived classes to provide a hook to modify a with any host-provided values that didn't come from the command line string.

Override by derived classes to provide a hook to modify a with any host-provided values that didn't come from the command line string.

Called by a derived class to notify that we need to update the settings in the project system for something that will be provided by either or .

A little helper type to hold onto the being updated in a batch, which also keeps track of the right to raise when we are done.

The kind that encompasses all the changes we've made. It's null if no changes have been made, and or if we can't give a more precise type.

The same as but also records the removed documents into .

Should be called to update the solution if there isn't a specific document change kind that should be given to

Calculates distance of two nodes based on their significant parts. Returns false if the nodes don't have any significant parts and should be compared as a whole.

Represents an edit operation on a tree or a sequence of nodes.

Tree node.

Insert: default(TNode). Delete: Deleted node. Move, Update: Node in the old tree/sequence.

Insert: Inserted node. Delete: default(TNode) Move, Update: Node in the new tree/sequence.

No change.

Node value was updated.

Node was inserted.

Node was deleted.

Node changed parent.

Node changed position within its parent. The parent nodes of the old node and the new node are matching.

Represents a sequence of tree edits.

Calculates Longest Common Subsequence for immutable arrays.

Limit the number of tokens used to compute distance between sequences of tokens so that we always use the pooled buffers. The combined length of the two sequences being compared must be less than .

Underlying storage for s allocated on .

The LCS algorithm allocates s of sizes (3, 2*1 + 1, ..., 2*D + 1), always in this order, where D is at most the sum of lengths of the compared sequences. The arrays get pushed on a stack as they are built up, then all consumed in the reverse order (stack pop). Since the exact length of each array in the above sequence is known we avoid allocating each individual array. Instead we allocate a large buffer serving as a a backing storage of a contiguous sequence of arrays corresponding to stack depths to . If more storage is needed we chain next large buffer to the previous one in a linked list. We pool a few of these linked buffers on to conserve allocations.

The max stack depth backed by the fist buffer. Size of the buffer for 100 is ~10K. For 150 it'd be 91KB, which would be allocated on LOH. The buffers grow by factor of , so the next buffer will be allocated on LOH.

Do not expand pooled buffers to more than ~12 MB total size (sum of all linked segment sizes). This threshold is achieved when is greater than = sqrt(size_limit / sizeof(int)).

Calculates Longest Common Subsequence.

Returns a distance [0..1] of the specified sequences. The smaller distance the more similar the sequences are.

Calculates a list of "V arrays" using Eugene W. Myers O(ND) Difference Algorithm

The algorithm was inspired by Myers' Diff Algorithm described in an article by Nicolas Butler: https://www.codeproject.com/articles/42279/investigating-myers-diff-algorithm-part-of The author has approved the use of his code from the article under the Apache 2.0 license. The algorithm works on an imaginary edit graph for A and B which has a vertex at each point in the grid(i, j), i in [0, lengthA] and j in [0, lengthB]. The vertices of the edit graph are connected by horizontal, vertical, and diagonal directed edges to form a directed acyclic graph. Horizontal edges connect each vertex to its right neighbor. Vertical edges connect each vertex to the neighbor below it. Diagonal edges connect vertex (i,j) to vertex (i-1,j-1) if (sequenceA[i-1],sequenceB[j-1]) is true. Move right along horizontal edge (i-1,j)-(i,j) represents a delete of sequenceA[i-1]. Move down along vertical edge (i,j-1)-(i,j) represents an insert of sequenceB[j-1]. Move along diagonal edge (i-1,j-1)-(i,j) represents an match of sequenceA[i-1] to sequenceB[j-1]. The number of diagonal edges on the path from (0,0) to (lengthA, lengthB) is the length of the longest common sub. The function does not actually allocate this graph. Instead it uses Eugene W. Myers' O(ND) Difference Algoritm to calculate a list of "V arrays" and returns it in a Stack. A "V array" is a list of end points of so called "snakes". A "snake" is a path with a single horizontal (delete) or vertical (insert) move followed by 0 or more diagonals (matching pairs). Unlike the algorithm in the article this implementation stores 'y' indexes and prefers 'right' moves instead of 'down' moves in ambiguous situations to preserve the behavior of the original diff algorithm (deletes first, inserts after). The number of items in the list is the length of the shortest edit script = the number of inserts/edits between the two sequences = D. The list can be used to determine the matching pairs in the sequences (GetMatchingPairs method) or the full editing script (GetEdits method). The algorithm uses O(ND) time and memory where D is the number of delete/inserts and N is the sum of lengths of the two sequences. VArrays store just the y index because x can be calculated: x = y + k.

Calculates longest common substring using Wagner algorithm.

Returns an edit script (a sequence of edits) that transform subtree to subtree.

Returns an edit script (a sequence of edits) that transform a sequence of nodes to a sequence of nodes .

or is a null reference.

Represents an edit operation on a sequence of values.

The kind of edit: , , or .

Index in the old sequence, or -1 if the edit is insert.

Index in the new sequence, or -1 if the edit is delete.

Implements a tree differencing algorithm.

Subclasses define relationships among tree nodes, and parameters to the differencing algorithm. Tree node.

Returns an edit script that transforms to .

Returns a match map of descendants to descendants.

Calculates the distance [0..1] of two nodes.

The more similar the nodes the smaller the distance. Used to determine whether two nodes of the same label match. Even if 0 is returned the nodes might be slightly different.

Returns true if the specified nodes have equal values.

Called with matching nodes (, ). Return true if the values of the nodes are the same, or their difference is not important.

The number of distinct labels used in the tree.

Returns an integer label corresponding to the given node.

Returned value must be within [0, LabelCount).

Returns N > 0 if the node with specified label can't change its N-th ancestor node, zero otherwise.

1st ancestor is the node's parent node. 2nd ancestor is the node's grandparent node. etc.

May return null if the is a leaf.

Enumerates all descendant nodes of the given node in depth-first prefix order.

Returns a parent for the specified node.

Return true if specified nodes belong to the same tree.

Returns the position of the node.

This should contain only language-agnostic declarations. Things like record struct should fall under struct, etc.

Represents a class declaration, including record class declarations in C#.

Represents a struct declaration, including record struct declarations in C#.

Represents set accessor declaration of a property, including init accessors in C#.

An editor for making changes to a document's syntax tree.

Creates a new instance.

The specified when the editor was first created.

The of the original document.

Returns the changed .

Adds namespace imports / using directives for namespace references found in the document.

Adds namespace imports / using directives for namespace references found in the document within the span specified.

Adds namespace imports / using directives for namespace references found in the document within the sub-trees annotated with the .

Adds namespace imports / using directives for namespace references found in the document within the spans specified.

Adds namespace imports / using directives for namespace references found in the document.

Adds namespace imports / using directives for namespace references found in the document within the sub-trees annotated with the .

Adds namespace imports / using directives for namespace references found in the document within the spans specified.

Adds namespace imports / using directives for namespace references found in the document.

Adds namespace imports / using directives for namespace references found in the document within the sub-trees annotated with the .

The name assigned to an implicit (widening) conversion.

The name assigned to an explicit (narrowing) conversion.

The name assigned to the Addition operator.

The name assigned to the BitwiseAnd operator.

The name assigned to the BitwiseOr operator.

The name assigned to the Decrement operator.

The name assigned to the Division operator.

The name assigned to the Equality operator.

The name assigned to the ExclusiveOr operator.

The name assigned to the False operator.

The name assigned to the GreaterThan operator.

The name assigned to the GreaterThanOrEqual operator.

The name assigned to the Increment operator.

The name assigned to the Inequality operator.

The name assigned to the LeftShift operator.

The name assigned to the LessThan operator.

The name assigned to the LessThanOrEqual operator.

The name assigned to the LogicalNot operator.

The name assigned to the Modulus operator.

The name assigned to the Multiply operator.

The name assigned to the OnesComplement operator.

The name assigned to the RightShift operator.

The name assigned to the Subtraction operator.

The name assigned to the True operator.

The name assigned to the UnaryNegation operator.

The name assigned to the UnaryPlus operator.

The name assigned to the UnsignedRightShift operator.

An editor for making changes to multiple documents in a solution.

The that was specified when the was constructed.

Gets the for the corresponding .

Returns the changed .

An editor for making changes to symbol source declarations.

Creates a new instance.

The original solution.

The solution with the edits applied.

The documents changed since the was constructed.

Gets the current symbol for a source symbol.

Gets the current declarations for the specified symbol.

Gets the declaration syntax nodes for a given symbol.

Gets the best declaration node for adding members.

An action that make changes to a declaration node within a .

The to apply edits to. The declaration to edit.

An action that make changes to a declaration node within a .

The to apply edits to. The declaration to edit. A cancellation token.

Enables editing the definition of one of the symbol's declarations. Partial types and methods may have more than one declaration.

The symbol to edit. The action that makes edits to the declaration. An optional . The new symbol including the changes.

Enables editing the definition of one of the symbol's declarations. Partial types and methods may have more than one declaration.

The symbol to edit. The action that makes edits to the declaration. An optional . The new symbol including the changes.

Enables editing the definition of one of the symbol's declarations. Partial types and methods may have more than one declaration.

The symbol to edit. A location within one of the symbol's declarations. The action that makes edits to the declaration. An optional . The new symbol including the changes.

Enables editing the definition of one of the symbol's declarations. Partial types and methods may have more than one declaration.

The symbol to edit. A location within one of the symbol's declarations. The action that makes edits to the declaration. An optional . The new symbol including the changes.

Enables editing the symbol's declaration where the member is also declared. Partial types and methods may have more than one declaration.

The symbol to edit. A symbol whose declaration is contained within one of the primary symbol's declarations. The action that makes edits to the declaration. An optional . The new symbol including the changes.

Enables editing the symbol's declaration where the member is also declared. Partial types and methods may have more than one declaration.

Enables editing all the symbol's declarations. Partial types and methods may have more than one declaration.

The symbol to be edited. The action that makes edits to the declaration. An optional . The new symbol including the changes.

Enables editing all the symbol's declarations. Partial types and methods may have more than one declaration.

The symbol to be edited. The action that makes edits to the declaration. An optional . The new symbol including the changes.

Gets the reference to the declaration of the base or interface type as part of the symbol's declaration.

Changes the base type of the symbol.

An editor for making changes to a syntax tree. The editor works by giving a list of changes to perform to a particular tree in order. Changes are given a they will apply to in the original tree the editor is created for. The semantics of application are as follows: The original root provided is used as the 'current' root for all operations. This 'current' root will continually be updated, becoming the new 'current' root. The original root is never changed. Each change has its given tracked, using a , producing a 'current' root that tracks all of them. This allows that same node to be found after prior changes are applied which mutate the tree. Each change is then applied in order it was added to the editor. A change first attempts to find its in the 'current' root. If that node cannot be found, the operation will fail with an . The particular change will run on that node, removing, replacing, or inserting around it according to the change. If the change is passed a delegate as its 'compute' argument, it will be given the found in the current root. The 'current' root will then be updated by replacing the current node with the new computed node. The 'current' root is then returned.

The above editing strategy makes it an error for a client of the editor to add a change that updates a parent node and then adds a change that updates a child node (unless the parent change is certain to contain the child), and attempting this will throw at runtime. If a client ever needs to update both a child and a parent, it should add the child change first, and then the parent change. And the parent change should pass an appropriate 'compute' callback so it will see the results of the child change. If a client wants to make a replacement, then find the value put into the tree, that can be done by adding a dedicated annotation to that node and then looking it back up in the 'current' node passed to a 'compute' callback.

Creates a new instance.

The that was specified when the was constructed.

A to use to create and change 's.

Returns the changed root node.

Makes sure the node is tracked, even if it is not changed.

Remove the node from the tree.

The node to remove that currently exists as part of the tree.

Remove the node from the tree.

The node to remove that currently exists as part of the tree. Options that affect how node removal works.

Replace the specified node with a node produced by the function.

The node to replace that already exists in the tree. A function that computes a replacement node. The node passed into the compute function includes changes from prior edits. It will not appear as a descendant of the original root.

Replace the specified node with a different node.

The node to replace that already exists in the tree. The new node that will be placed into the tree in the existing node's location.

Insert the new nodes before the specified node already existing in the tree.

The node already existing in the tree that the new nodes will be placed before. This must be a node this is contained within a syntax list. The nodes to place before the existing node. These nodes must be of a compatible type to be placed in the same list containing the existing node.

Insert the new node before the specified node already existing in the tree.

The node already existing in the tree that the new nodes will be placed before. This must be a node this is contained within a syntax list. The node to place before the existing node. This node must be of a compatible type to be placed in the same list containing the existing node.

Insert the new nodes after the specified node already existing in the tree.

The node already existing in the tree that the new nodes will be placed after. This must be a node this is contained within a syntax list. The nodes to place after the existing node. These nodes must be of a compatible type to be placed in the same list containing the existing node.

Insert the new node after the specified node already existing in the tree.

The node already existing in the tree that the new nodes will be placed after. This must be a node this is contained within a syntax list. The node to place after the existing node. This node must be of a compatible type to be placed in the same list containing the existing node.

A language agnostic factory for creating syntax nodes. This API can be used to create language specific syntax nodes that are semantically similar between languages. The trees generated by this API will try to respect user preferences when possible. For example, generating will be done in a way such that "this." or "Me." will be simplified according to user preference if is used.

Gets the for the specified language.

Gets the for the language corresponding to the document.

Gets the for the language corresponding to the project.

Returns the node if it is a declaration, the immediate enclosing declaration if one exists, or null.

Returns the enclosing declaration of the specified kind or null.

Creates a field declaration.

Creates a field declaration matching an existing field symbol.

Creates a method declaration.

Creates a method declaration matching an existing method symbol.

Creates a method declaration.

Creates a operator or conversion declaration matching an existing method symbol.

Creates a parameter declaration.

Creates a parameter declaration matching an existing parameter symbol.

Creates a property declaration. The property will have a get accessor if is and will have a set accessor if is .

In C# there is a distinction between passing in for or versus passing in an empty list. will produce an auto-property-accessor (i.e. get;) whereas an empty list will produce an accessor with an empty block (i.e. get { }).

Creates a property declaration using an existing property symbol as a signature.

Creates an indexer declaration.

Creates an indexer declaration matching an existing indexer symbol.

Creates a statement that adds the given handler to the given event.

Creates a statement that removes the given handler from the given event.

Creates an event declaration.

Creates an event declaration from an existing event symbol

Creates a custom event declaration.

Creates a custom event declaration from an existing event symbol.

Creates a constructor declaration.

Create a constructor declaration using

Converts method, property and indexer declarations into public interface implementations. This is equivalent to an implicit C# interface implementation (you can access it via the interface or directly via the named member.)

Converts method, property and indexer declarations into private interface implementations. This is equivalent to a C# explicit interface implementation (you can declare it for access via the interface, but cannot call it directly).

Creates a class declaration.

Creates a struct declaration.

Creates a interface declaration.

Creates an enum declaration.

Creates an enum declaration

Creates an enum member

Creates a delegate declaration.

Creates a declaration matching an existing symbol.

Converts a declaration (method, class, etc) into a declaration with type parameters.

Adds a type constraint to a type parameter of a declaration.

Creates a namespace declaration.

The name of the namespace. Zero or more namespace or type declarations.

Creates a namespace declaration.

The name of the namespace. Zero or more namespace or type declarations.

Creates a namespace declaration.

The name of the namespace. Zero or more namespace or type declarations.

Creates a namespace declaration.

The name of the namespace. Zero or more namespace or type declarations.

Creates a compilation unit declaration

Zero or more namespace import, namespace or type declarations.

Creates a compilation unit declaration

Zero or more namespace import, namespace or type declarations.

Creates a namespace import declaration.

The name of the namespace being imported.

Creates a namespace import declaration.

The name of the namespace being imported.

Creates an alias import declaration.

The name of the alias. The namespace or type to be aliased.

Creates an alias import declaration.

The name of the alias. The namespace or type to be aliased.

Creates an attribute.

Creates an attribute matching existing attribute data.

Creates an attribute argument.

Removes all attributes from the declaration, including return attributes.

Removes comments from leading and trailing trivia, as well as potentially removing comments from opening and closing tokens.

Gets the attributes of a declaration, not including the return attributes.

Creates a new instance of the declaration with the attributes inserted.

Creates a new instance of a declaration with the specified attributes added.

Gets the return attributes from the declaration.

Creates a new instance of a method declaration with return attributes inserted.

Creates a new instance of a method declaration with return attributes added.

Creates a new instance of a method declaration node with return attributes added.

Gets the attribute arguments for the attribute declaration.

Creates a new instance of the attribute with the arguments inserted.

Creates a new instance of the attribute with the arguments added.

Gets the namespace imports that are part of the declaration.

Creates a new instance of the declaration with the namespace imports inserted.

Creates a new instance of the declaration with the namespace imports added.

Gets the current members of the declaration.

Creates a new instance of the declaration with the members inserted.

Creates a new instance of the declaration with the members added to the end.

Gets the accessibility of the declaration.

Changes the accessibility of the declaration.

Gets the for the declaration.

Changes the for the declaration.

Gets the for the declaration.

Gets the name of the declaration.

Changes the name of the declaration.

Gets the type of the declaration.

Changes the type of the declaration.

Gets the list of parameters for the declaration.

Inserts the parameters at the specified index into the declaration.

Adds the parameters to the declaration.

Gets the list of switch sections for the statement.

Inserts the switch sections at the specified index into the statement.

Adds the switch sections to the statement.

Gets the expression associated with the declaration.

Changes the expression associated with the declaration.

Gets the statements for the body of the declaration.

Changes the statements for the body of the declaration.

Gets the accessors for the declaration.

Gets the accessor of the specified kind for the declaration.

Creates a new instance of the declaration with the accessors inserted.

Creates a new instance of the declaration with the accessors added.

Gets the statements for the body of the get-accessor of the declaration.

Changes the statements for the body of the get-accessor of the declaration.

Gets the statements for the body of the set-accessor of the declaration.

Changes the statements for the body of the set-accessor of the declaration.

Gets a list of the base and interface types for the declaration.

Adds a base type to the declaration

Adds an interface type to the declaration

Replaces the node in the root's tree with the new node.

Inserts the new node before the specified declaration.

Removes the node from the sub tree starting at the root.

Removes all the declarations from the sub tree starting at the root.

Creates a new instance of the node with the leading and trailing trivia removed and replaced with elastic markers.

Creates statement that allows an expression to execute in a statement context. This is typically an invocation or assignment expression.

The expression that is to be executed. This is usually a method invocation expression.

Creates a statement that can be used to return a value from a method body.

An optional expression that can be returned.

Creates a statement that can be used to yield a value from an iterator method.

An expression that can be yielded.

Creates a statement that can be used to throw an exception.

An optional expression that can be thrown.

Creates an expression that can be used to throw an exception.

True if can be used

if the language requires a (including ) to be stated when making a . if the language allows the type node to be entirely elided.

Creates a statement that declares a single local variable.

Creates an if-statement

A condition expression. The statements that are executed if the condition is true. The statements that are executed if the condition is false.

Creates an if statement

A condition expression. The statements that are executed if the condition is true. A single statement that is executed if the condition is false.

Creates a switch statement that branches to individual sections based on the value of the specified expression.

Creates a section for a switch statement.

Creates a single-case section a switch statement.

Creates a default section for a switch statement.

Create a statement that exits a switch statement and continues after it.

Creates a statement that represents a using-block pattern.

Creates a statement that represents a lock-block pattern.

Creates a try-catch or try-catch-finally statement.

Creates a try-finally statement.

Creates a catch-clause.

Creates a while-loop statement

Creates a block of statements. Not supported in VB.

An expression that represents the default value of a type. This is typically a null value for reference types or a zero-filled value for value types.

Creates an expression that denotes the containing method's this-parameter.

Creates an expression that denotes the containing method's base-parameter.

Creates a literal expression. This is typically numeric primitives, strings or chars.

Creates an expression for a typed constant.

Creates an expression that denotes the boolean false literal.

Creates an expression that denotes the boolean true literal.

Creates an expression that denotes the null literal.

Creates an expression that denotes a simple identifier name.

Creates an expression that denotes a generic identifier name.

Converts an expression that ends in a name into an expression that ends in a generic name. If the expression already ends in a generic name, the new type arguments are used instead.

Creates a name expression that denotes a qualified name. The left operand can be any name expression. The right operand can be either and identifier or generic name.

Returns a new name node qualified with the 'global' alias ('Global' in VB).

Creates a name expression from a dotted name string.

Creates a name that denotes a type or namespace.

The symbol to create a name for.

Creates an expression that denotes a type.

Creates an expression that denotes a type. If addImport is false, adds a which will prevent any imports or usings from being added for the type.

Creates an expression that denotes a special type name.

Creates an expression that denotes an array type.

Creates an expression that denotes a nullable type.

Creates an expression that denotes a tuple type.

Creates an expression that denotes a tuple element.

Creates an expression that denotes an assignment from the right argument to left argument.

Creates an expression that denotes a value-type equality test operation.

Creates an expression that denotes a reference-type equality test operation.

Creates an expression that denotes a value-type inequality test operation.

Creates an expression that denotes a reference-type inequality test operation.

Creates an expression that denotes a less-than test operation.

Creates an expression that denotes a less-than-or-equal test operation.

Creates an expression that denotes a greater-than test operation.

Creates an expression that denotes a greater-than-or-equal test operation.

Creates an expression that denotes a unary negation operation.

Creates an expression that denotes an addition operation.

Creates an expression that denotes an subtraction operation.

Creates an expression that denotes a multiplication operation.

Creates an expression that denotes a division operation.

Creates an expression that denotes a modulo operation.

Creates an expression that denotes a bitwise-and operation.

Creates an expression that denotes a bitwise-or operation.

Creates an expression that denotes a bitwise-not operation

Creates an expression that denotes a logical-and operation.

Creates an expression that denotes a logical-or operation.

Creates an expression that denotes a logical not operation.

Creates an expression that denotes a conditional evaluation operation.

Creates an expression that denotes a conditional access operation. Use and to generate the argument.

Creates an expression that denotes a member binding operation.

Creates an expression that denotes an element binding operation.

Creates an expression that denotes a coalesce operation.

Creates a member access expression.

Creates an array creation expression for a single dimensional array of specified size.

Creates an array creation expression for a single dimensional array with specified initial element values.

Creates an object creation expression.

Creates a invocation expression.

Creates a invocation expression

Creates a node that is an argument to an invocation.

Creates an expression that access an element of an array or indexer.

Creates an expression that evaluates to the type at runtime.

Creates an expression that denotes an is-type-check operation.

Creates an expression that denotes an try-cast operation.

Creates an expression that denotes a type cast operation.

Creates an expression that denotes a type conversion operation.

Creates an expression that declares a value returning lambda expression.

Creates an expression that declares a void returning lambda expression

Creates an expression that declares a value returning lambda expression.

Creates an expression that declares a void returning lambda expression.

Creates an expression that declares a single parameter value returning lambda expression.

Creates an expression that declares a single parameter void returning lambda expression.

Creates an expression that declares a single parameter value returning lambda expression.

Creates an expression that declares a single parameter void returning lambda expression.

Creates an expression that declares a zero parameter value returning lambda expression.

Creates an expression that declares a zero parameter void returning lambda expression.

Creates an expression that declares a zero parameter value returning lambda expression.

Creates an expression that declares a zero parameter void returning lambda expression.

Creates a lambda parameter.

Creates an await expression.

Wraps with parens.

Creates an nameof expression.

Creates an tuple expression.

Parses an expression from string

Has the reference type constraint (i.e. 'class' constraint in C#)

Has the value type constraint (i.e. 'struct' constraint in C#)

Has the constructor constraint (i.e. 'new' constraint in C#)

Options that we expect the user to set in editorconfig.

Looks at the contents of the document for top level identifiers (or existing extension method calls), and blocks off imports that could potentially bring in a name that would conflict with them. is the node that the import will be added to. This will either be the compilation-unit node, or one of the namespace-blocks in the file.

Checks if the namespace declaration is contained inside, or any of its ancestor namespaces are the same as

Internal extensions to . This interface is available in the shared CodeStyle and Workspaces layer to allow sharing internal generator methods between them. Once the methods are ready to be made public APIs, they can be moved to .

Creates a statement that declares a single local variable with an optional initializer.

Creates a statement that declares a single local variable.

Wraps with parens.

Creates a statement that can be used to yield a value from an iterator method.

An expression that can be yielded.

if the language requires a "TypeExpression" (including ) to be stated when making a . if the language allows the type node to be entirely elided.

Produces an appropriate TypeSyntax for the given . The flag controls how this should be created depending on if this node is intended for use in a type-only context, or an expression-level context. In the former case, both C# and VB will create QualifiedNameSyntax nodes for dotted type names, whereas in the latter case both languages will create MemberAccessExpressionSyntax nodes. The final stringified result will be the same in both cases. However, the structure of the trees will be substantively different, which can impact how the compilation layers analyze the tree and how transformational passes affect it.

Passing in the right value for is necessary for correctness and for use of compilation (and other) layers in a supported fashion. For example, if a QualifiedTypeSyntax is sed in a place the compiler would have parsed out a MemberAccessExpression, then it is undefined behavior what will happen if that tree is passed to any other components.

Name of the host to be used in error messages (e.g. "Visual Studio").

Show global error info. this kind error info should be something that affects whole roslyn such as background compilation is disabled due to memory issue and etc

Thrown when async code must cancel the current execution but does not have access to the of the passed to the code. Should be used in very rare cases where the is out of our control (e.g. owned but not exposed by JSON RPC in certain call-back scenarios).

Set by the host to handle an error report; this may crash the process or report telemetry.

A handler that will not crash the process when called. Used when calling

Same as setting the Handler property except that it avoids the assert. This is useful in test code which needs to verify the handler is called in specific cases and will continually overwrite this value.

Copies the handler in this instance to the linked copy of this type in this other assembly.

This file is in linked into multiple layers, but we want to ensure that all layers have the same copy. This lets us copy the handler in this instance into the same in another instance.

Use in an exception filter to report an error without catching the exception. The error is reported by calling .

to avoid catching the exception.

Use in an exception filter to report an error (by calling ), unless the operation has been cancelled. The exception is never caught.

to avoid catching the exception.

Use in an exception filter to report an error (by calling ), unless the operation has been cancelled at the request of . The exception is never caught. Cancellable operations are only expected to throw if the applicable indicates cancellation is requested by setting . Unexpected cancellation, i.e. an which occurs without requesting cancellation, is treated as an error by this method. This method does not require to match , provided cancellation is expected per the previous paragraph.

A which will have set if cancellation is expected. to avoid catching the exception.

Report an error. Calls and doesn't pass the exception through (the method returns true). This is generally expected to be used within an exception filter as that allows us to capture data at the point the exception is thrown rather than when it is handled. However, it can also be used outside of an exception filter. If the exception has not already been thrown the method will throw and catch it itself to ensure we get a useful stack trace.

True to catch the exception.

Use in an exception filter to report an error (by calling ) and catch the exception, unless the operation was cancelled.

to catch the exception if the error was reported; otherwise, to propagate the exception if the operation was cancelled.

Use in an exception filter to report an error (by calling ) and catch the exception, unless the operation was cancelled at the request of . Cancellable operations are only expected to throw if the applicable indicates cancellation is requested by setting . Unexpected cancellation, i.e. an which occurs without requesting cancellation, is treated as an error by this method. This method does not require to match , provided cancellation is expected per the previous paragraph.

A which will have set if cancellation is expected. to catch the exception if the error was reported; otherwise, to propagate the exception if the operation was cancelled.

Used to report a non-fatal-watson (when possible) to report an exception. The exception is not caught. Does nothing if no non-fatal error handler is registered. See the second argument to .

The severity of the error, see the enum members for a description of when to use each. This is metadata that's included in a non-fatal fault report, which we can take advantage of on the backend to automatically triage bugs. For example, a critical severity issue we can open with a lower bug count compared to a low priority one.

The severity hasn't been categorized. Don't use this in new code.

Something failed, but the user is unlikely to notice. Especially useful for background things that we can silently recover from, like bugs in caching systems.

Something failed, and the user might notice, but they're still likely able to carry on. For example, if the user asked for some information from the IDE (find references, completion, etc.) and we were able to give partial results.

Something failed, and the user likely noticed. For example, the user pressed a button to do an action, and we threw an exception so we completely failed to do that in an unrecoverable way. This may also be used for back-end systems where a failure is going to result in a highly broken experience, for example if parsing a file catastrophically failed.

Returns to make it easy to use in an exception filter. Note: will be called with any exception, so this should not do anything in the case of .

All options needed to perform method extraction.

Provides helper methods for finding dependent projects across a solution that a given symbol can be referenced within.

Cache from the for a particular to the name of the defined by it.

This method computes the dependent projects that need to be searched for references of the given . This computation depends on the given symbol's visibility: Public: Dependent projects include the symbol definition project and all the referencing projects. Internal: Dependent projects include the symbol definition project and all the referencing projects that have internals access to the definition project.. Private: Dependent projects include the symbol definition project and all the referencing submission projects (which are special and can reference private fields of the previous submission). We perform this computation in two stages: Compute all the dependent projects (submission + non-submission) and their InternalsVisibleTo semantics to the definition project. Filter the above computed dependent projects based on symbol visibility. Dependent projects computed in stage (1) are cached to avoid recomputation.

Returns information about where originate from. It's for both source and metadata symbols, and an optional if this was a symbol from source.

Provides helper methods for finding dependent types (derivations, implementations, etc.) across a solution. This is effectively a graph walk between INamedTypeSymbols walking down the inheritance hierarchy to find related types based either on or .

While walking up the inheritance hierarchy is trivial (as the information is directly contained on the 's themselves), walking down is complicated. The general way this works is by using out-of-band indices that are built that store this type information in a weak manner. Specifically, for both source and metadata types we have indices that map between the base type name and the inherited type name. i.e. for the case class A { } class B : A { } the index stores a link saying "There is a type 'A' somewhere which has derived type called 'B' somewhere". So when the index is examined for the name 'A', it will say 'examine types called 'B' to see if they're an actual match'. These links are then continually traversed to get the full set of results.

Walks down a 's inheritance tree looking for more 's that match the provided predicate.

Called when a new match is found to check if that type's inheritance tree should also be walked down. Can be used to stop the search early if a type could have no types that inherit from it that would match this search. If this search after finding the direct inherited types that match the provided predicate, or if the search should continue recursively using those types as the starting point.

Moves all the types in to . If these are types we haven't seen before, and the caller says we on them, then add them to for the next round of searching.

We cache the project instance per . This allows us to reuse it over a wide set of changes (for example, changing completely unrelated projects that a particular project doesn't depend on). However, doesn't change even when certain things change that will create a substantively different . For example, if the for the project changes, we'll still have the same project state. As such, we store the of the project as well, ensuring that if anything in it or its dependencies changes, we recompute the index.

Finds all the documents in the provided project that contain the requested string values

Finds all the documents in the provided project that contain a global attribute in them.

If the `node` implicitly matches the `symbol`, then it will be added to `locations`.

Find references to a symbol inside global suppressions. For example, consider a field 'Field' defined inside a type 'C'. This field's documentation comment ID is 'F:C.Field' A reference to this field inside a global suppression would be as following: [assembly: SuppressMessage("RuleCategory", "RuleId', Scope = "member", Target = "~F:C.Field")]

Validate and split a documentation comment ID into a prefix and complete symbol ID. For the ~M:C.X(System.String), the would be ~M: and would be C.X(System.String).

Split a full documentation symbol ID into the core symbol ID and optional parameter list. For the C.X(System.String), the would be C.X and would be (System.String).

Validate and split symbol documentation comment ID. For example, "~M:C.X(System.String)" represents the documentation comment ID of a method named 'X' that takes a single string-typed parameter and is contained in a type named 'C'. We divide the ID into 3 groups: 1. Prefix: - Starts with an optional '~' - Followed by a single capital letter indicating the symbol kind (for example, 'M' indicates method symbol) - Followed by ':' 2. Core symbol ID, which is its fully qualified name before the optional parameter list and return type (i.e. before the '(' or '[' tokens) 3. Optional parameter list and/or return type that begins with a '(' or '[' tokens. For the above example, "~M:" is the prefix, "C.X" is the core symbol ID and "(System.String)" is the parameter list.

Finds references to in this , but only if it referenced though (which might be the actual name of the type, or a global alias to it).

The actual node that we found the reference on. Normally the 'Name' portion of any piece of syntax. Might also be something like a 'foreach' statement node when finding results for something like GetEnumerator.

The location we want want to return through the FindRefs API. The location contains additional information (like if this was a Write, or if it was Implicit). This value also has a property. Importantly, this value is not necessarily the same location you would get by calling .. Instead, this location is where we want to navigate the user to. A case where this can be different is with an indexer reference. The will be the node for the full 'ElementAccessExpression', whereas the location we will take the user to will be the zero-length position immediately preceding the `[` character.

Extensibility interface to allow individual languages to extend the 'Find References' service. Languages can use this to provide specialized cascading logic between symbols that 'Find References' is searching for.

Extensibility interface to allow extending the IFindReferencesService service. Implementations must be thread-safe as the methods on this interface may be called on multiple threads simultaneously. Implementations should also respect the provided cancellation token and should try to cancel themselves quickly when requested.

Determines what, if any, global alias names could potentially map this symbol in this project. Note that this result is allowed to return global aliases that don't actually map to this symbol. For example, given symbol A.X and global alias G = B.X, G might be returned in a search for A.X because they both end in X.

Called by the find references search engine when a new symbol definition is found. Implementations can then choose to request more symbols be searched for. For example, an implementation could choose for the find references search engine to cascade to constructors when searching for standard types. Implementations of this method must be thread-safe.

Called by the find references search engine to determine which documents in the supplied project need to be searched for references. Only projects returned by DetermineProjectsToSearch will be passed to this method. Implementations should endeavor to keep the list of returned documents as small as possible to keep search time down to a minimum. Returning the entire list of documents in a project is not recommended (unless, of course, there is reasonable reason to believe there are references in every document). Implementations of this method must be thread-safe.

Called by the find references search engine to determine the set of reference locations in the provided document. Only documents returned by DetermineDocumentsToSearch will be passed to this method. Implementations of this method must be thread-safe.

Looks for documents likely containing in them. That name will either be the actual name of the named type we're looking for, or it might be a global alias to it.

Finds references to in this , but only if it referenced though (which might be the actual name of the type, or a global alias to it).

The list of common reference finders.

Caches information find-references needs associated with each document. Computed and cached so that multiple calls to find-references in a row can share the same data.

Not used by FAR directly. But we compute and cache this while processing a document so that if we call any other services that use this semantic model, that they don't end up recreating it.

Ephemeral information that find-references needs for a particular document when searching for a specific symbol. Importantly, it contains the global aliases to that symbol within the current project.

A does-nothing version of the . Useful for clients that have no need to report progress as they work.

Symbol set used when is . This symbol set will cascade up *and* down the inheritance hierarchy for all symbols we are searching for. This is the symbol set used for features like 'Rename', where all cascaded symbols must be updated in order to keep the code compiling.

When we're cascading in both direction, we can just keep all symbols in a single set. We'll always be examining all of them to go in both up and down directions in every project we process. Any time we add a new symbol to it we'll continue to cascade in both directions looking for more.

Scheduler we use when we're doing operations in the BG and we want to rate limit them to not saturate the threadpool.

Options to control the parallelism of the search. If we're in mode, we'll run all our tasks concurrently. Otherwise, we will run them serially using

Notify the caller of the engine about the definitions we've found that we're looking for. We'll only notify them once per symbol group, but we may have to notify about new symbols each time we expand our symbol set when we walk into a new project.

A symbol set used when the find refs caller does not want cascading. This is a trivial impl that basically just wraps the initial symbol provided and doesn't need to do anything beyond that.

Represents the set of symbols that the engine is searching for. While the find-refs engine is passed an initial symbol to find results for, the engine will often have to 'cascade' that symbol to many more symbols that clients will also need. This includes: Cascading to all linked symbols for the requested symbol. This ensures a unified set of results for a particular symbol, regardless of what project context it was originally found in. Symbol specific cascading. For example, when searching for a named type, references to that named type will be found through its constructors. Cascading up and down the inheritance hierarchy for members (e.g. methods, properties, events). This is controllable through the option.

Get a copy of all the symbols in the set. Cannot be called concurrently with

Update the set of symbols in this set with any appropriate symbols in the inheritance hierarchy brought in within . For example, given a project 'A' with interface interface IGoo { void Goo(); }, and a project 'B' with class class Goo : IGoo { public void Goo() { } }, then initially the symbol set will only contain IGoo.Goo. However, when project 'B' is processed, this will add Goo.Goo is added to the set as well so that references to it can be found.

This method is non thread-safe as it mutates the symbol set instance. As such, it should only be called serially. should not be called concurrently with this.

Determines the initial set of symbols that we should actually be finding references for given a request to find refs to . This will include any symbols that a specific cascades to, as well as all the linked symbols to those across any multi-targeting/shared-project documents. This will not include symbols up or down the inheritance hierarchy.

Finds all the symbols 'down' the inheritance hierarchy of in the given project. The symbols found are added to . If did not contain that symbol, then it is also added to to allow fixed point algorithms to continue.

will always be a single project. We just pass this in as a set to avoid allocating a fresh set every time this calls into FindMemberImplementationsArrayAsync.

Finds all the symbols 'up' the inheritance hierarchy of in the solution. The symbols found are added to . If did not contain that symbol, then it is also added to to allow fixed point algorithms to continue.

Symbol set used when is . This symbol set will only cascade in a uniform direction once it walks either up or down from the initial set of symbols. This is the symbol set used for features like 'Find Refs', where we only want to return location results for members that could feasible actually end up calling into that member at runtime. See the docs of for more information on this.

When we're doing a unidirectional find-references, the initial set of up-symbols can never change. That's because we have computed the up set entirely up front, and no down symbols can produce new up-symbols (as going down then up would not be unidirectional).

When searching for property, associate specific references we find to the relevant accessor symbol (if there is one). For example, in C#, this would result in: P = 0; // A reference to the P.set accessor var v = P; // A reference to the P.get accessor P++; // A reference to P.get and P.set accessors nameof(P); // A reference only to P. Not associated with a particular accessor. The default for this is false. With that default, all of the above references are associated with the property P and not the accessors. Whether or not we should cascade from the original search symbol to new symbols as we're doing the find-references search. Whether or not this find ref operation was explicitly invoked or not. If explicit invoked, the find references operation may use more resources to get the results faster. Features that run automatically should consider setting this to to avoid unnecessarily impacting the user while they are doing other work. When cascading if we should only travel in a consistent direction away from the starting symbol. For example, starting on a virtual method, this would cascade upwards to implemented interface methods, and downwards to overridden methods. However, it would not then travel back down to other implementations of those interface methods. This is useful for cases where the client only wants references that could lead to this symbol actually being called into at runtime. There are cases where a client will not want this behavior. An example of that is 'Rename'. In rename, there is a implicit link between members in a hierarchy with the same name (and appropriate signature). For example, in:


             interface I { void Goo(); }
             class C1 : I { public void Goo() { } }
             class C2 : I { public void Goo() { } }

If C1.Goo is renamed, this will need to rename C2.Goo as well to keep the code properly compiling. So, by default 'Rename' will cascade to all of these so it can appropriately update them. This option is the more relevant with knowing if a particular reference would actually result in a call to the original member, not if it has a relation to the original member. Displays all definitions regardless of whether they have a reference or not.


             interface I { void Goo(); }
             class C1 : I { public void Goo() { } }
             class C2 : I { public void Goo() { } }

Returns the appropriate options for a given symbol for the specific 'Find References' feature. This should not be used for other features (like 'Rename'). For the 'Find References' feature, if the user starts searching on an accessor, then we want to give results associated with the specific accessor. Otherwise, if they search on a property, then associate everything with the property. We also only want to travel an inheritance hierarchy unidirectionally so that we only see potential references that could actually reach this particular member.

A does-nothing version of the . Useful for clients that have no need to report progress as they work.

Wraps an into an so it can be used from the new streaming find references APIs.

Reports the progress of the FindReferences operation. Note: these methods may be called on any thread.

Represents a group of s that should be treated as a single entity for the purposes of presentation in a Find UI. For example, when a symbol is defined in a file that is linked into multiple project contexts, there will be several unique symbols created that we search for. Placing these in a group allows the final consumer to know that these symbols can be merged together.

All the symbols in the group.

Reports the progress of the FindReferences operation. Note: these methods may be called on any thread.

Represents a single result of the call to the synchronous IFindReferencesService.FindReferences method. Finding the references to a symbol will result in a set of definitions being returned (containing at least the symbol requested) as well as any references to those definitions in the source. Multiple definitions may be found due to how C# and VB allow a symbol to be both a definition and a reference at the same time (for example, a method which implements an interface method).

The symbol definition that these are references to.

Same as but exposed as an for performance.

The set of reference locations in the solution.

Information about a reference to a symbol.

The document that the reference was found in.

If the symbol was bound through an alias, then this is the alias that was used.

The actual source location for a given symbol.

Indicates if this is an implicit reference to the definition. i.e. the definition wasn't explicitly stated in the source code at this position, but it was still referenced. For example, this can happen with special methods like GetEnumerator that are used implicitly by a 'for each' statement.

Indicates if this is a location where the reference is written to.

Symbol usage info for this reference.

Additional properties for this reference

If this reference location is within a string literal, then this property indicates the location of the containing string literal token. Otherwise, .

Creates a reference location with the given properties.

Creates a reference location within a string literal. For example, location inside the target string of a global SuppressMessageAttribute.

Indicates if this was not an exact reference to a location, but was instead a possible location that was found through error tolerance. For example, a call to a method like "Goo()" could show up as an error tolerance location to a method "Goo(int i)" if no actual "Goo()" method existed.

Use an case-sensitive comparison when searching for matching items.

Use a case-insensitive comparison when searching for matching items.

Use a fuzzy comparison when searching for matching items. Fuzzy matching allows for a certain amount of misspellings, missing words, etc. See for more details.

Search term is matched in a custom manner (i.e. with a user provided predicate).

The name being searched for. Is null in the case of custom predicate searching.. But can be used for faster index based searching when it is available.

The kind of search this is. Faster index-based searching can be used if the SearchKind is not .

The predicate to fall back on if faster index searching is not possible.

Not readonly as this is mutable struct.

Increment this whenever the data format of the changes. This ensures that we will not try to read previously cached data from a prior version of roslyn with a different format and will instead regenerate all the indices with the new format.

Cache of ParseOptions to a checksum for the contained within. Useful so we don't have to continually reenumerate and regenerate the checksum given how rarely these ever change.

Collects all the definitions and references that are reported independently and packages them up into the final list of . This is used by the old non-streaming Find-References APIs to return all the results at the end of the operation, as opposed to broadcasting the results as they are found.

Contains information about a call from one symbol to another. The symbol making the call is stored in CallingSymbol and the symbol that the call was made to is stored in CalledSymbol. Whether or not the call is direct or indirect is also stored. A direct call is a call that does not go through any other symbols in the inheritance hierarchy of CalledSymbol, while an indirect call does go through the inheritance hierarchy. For example, calls through a base member that this symbol overrides, or through an interface member that this symbol implements will be considered 'indirect'.

The symbol that is calling the symbol being called.

The locations inside the calling symbol where the called symbol is referenced.

The symbol being called.

True if the CallingSymbol is directly calling CalledSymbol. False if it is calling a symbol in the inheritance hierarchy of the CalledSymbol. For example, if the called symbol is a class method, then an indirect call might be through an interface method that the class method implements.

Obsolete. Use .

Finds the symbol that is associated with a position in the text of a document.

The semantic model associated with the document. The character position within the document. A workspace to provide context. A CancellationToken.

Finds the symbol that is associated with a position in the text of a document.

The semantic model associated with the document. The character position within the document. A CancellationToken.

Finds the symbol that is associated with a position in the text of a document.

The semantic model associated with the document. The character position within the document. True to include the type of the symbol in the search. A CancellationToken.

Finds the definition symbol declared in source code for a corresponding reference symbol. Returns null if no such symbol can be found in the specified solution.

Finds symbols in the given compilation that are similar to the specified symbol. A found symbol may be the exact same symbol instance if the compilation is the origin of the specified symbol, or it may be a different symbol instance if the compilation is not the originating compilation. Multiple symbols may be returned if there are ambiguous matches. No symbols may be returned if the compilation does not define or have access to a similar symbol.

The symbol to find corresponding matches for. A compilation to find the corresponding symbol within. The compilation may or may not be the origin of the symbol. A CancellationToken.

If is declared in a linked file, then this function returns all the symbols that are defined by the same symbol's syntax in the all projects that the linked file is referenced from. In order to be returned the other symbols must have the same and as . This matches general user intuition that these are all the 'same' symbol, and should be examined, regardless of the project context and they originally started with.

Callback object we pass to the OOP server to hear about the result of the FindReferencesEngine as it executes there.

Finds all the callers of a specified symbol.

Find the declared symbols from either source, referenced projects or metadata assemblies with the specified name.

Find the symbols for declarations made in source with a matching name.

Find the symbols for declarations made in source with the specified name.

Find the symbols for declarations made in source with the specified pattern. This pattern is matched using heuristics that may change from release to release. So, the set of symbols matched by a given pattern may change between releases. For example, new symbols may be matched by a pattern and/or symbols previously matched by a pattern no longer are. However, the set of symbols matched by a specific release will be consistent for a specific pattern.

Finds all references to a symbol throughout a solution

The symbol to find references to. The solution to find references within. A cancellation token.

Finds all references to a symbol throughout a solution

The symbol to find references to. The solution to find references within. A set of documents to be searched. If documents is null, then that means "all documents". A cancellation token.

Finds all references to a symbol throughout a solution

The symbol to find references to. The solution to find references within. An optional progress object that will receive progress information as the search is undertaken. An optional set of documents to be searched. If documents is null, then that means "all documents". An optional cancellation token.

Verifies that all pairs of named types in equivalentTypesWithDifferingAssemblies are equivalent forwarded types.

Returns if was forwarded to in 's .

Find symbols for members that override the specified member symbol.

Use this overload to avoid boxing the result into an .

Find symbols for declarations that implement members of the specified interface symbol

Use this overload to avoid boxing the result into an .

Finds all the derived classes of the given type. Implementations of an interface are not considered "derived", but can be found with .

The symbol to find derived types of. The solution to search in. The projects to search. Can be null to search the entire solution. The derived types of the symbol. The symbol passed in is not included in this list.

Finds the derived classes of the given type. Implementations of an interface are not considered "derived", but can be found with .

The symbol to find derived types of. The solution to search in. If the search should stop at immediately derived classes, or should continue past that. The projects to search. Can be null to search the entire solution. The derived types of the symbol. The symbol passed in is not included in this list. Use this overload to avoid boxing the result into an .

Finds the derived interfaces of the given interfaces.

The symbol to find derived types of. The solution to search in. If the search should stop at immediately derived interfaces, or should continue past that. The projects to search. Can be null to search the entire solution. The derived interfaces of the symbol. The symbol passed in is not included in this list. Use this overload to avoid boxing the result into an .

Finds the accessible or types that implement the given interface.

The symbol to find derived types of. The solution to search in. If the search should stop at immediately derived interfaces, or should continue past that. The projects to search. Can be null to search the entire solution. Use this overload to avoid boxing the result into an .

Finds all the accessible symbols that implement an interface or interface member. For an this will be both immediate and transitive implementations.

Use this overload to avoid boxing the result into an .

Computes and caches indices for the source symbols in s and for metadata symbols in s.

Can't be null. Even if we weren't able to read in metadata, we'll still create an empty index.

The set of projects that are referencing this metadata-index. When this becomes empty we can dump the index from memory.

Accesses to this collection must lock the set.

Same value as SolutionCrawlerTimeSpan.EntireProjectWorkerBackOff

Scheduler to run our tasks on. If we're in the remote host , we'll run all our tasks concurrently. Otherwise, we will run them serially using

Gets the latest computed for the requested . This may return an index corresponding to a prior version of the reference if it has since changed. Another system is responsible for bringing these indices up to date in the background.

Represents a tree of names of the namespaces, types (and members within those types) within a or . This tree can be used to quickly determine if there is a name match, and can provide the named path to that named entity. This path can then be used to produce a corresponding that can be used by a feature. The primary purpose of this index is to allow features to quickly determine that there is no name match, so that acquiring symbols is not necessary. The secondary purpose is to generate a minimal set of symbols when there is a match, though that will still incur a heavy cost (for example, getting the root symbol for a particular project).

The list of nodes that represent symbols. The primary key into the sorting of this list is the name. They are sorted case-insensitively . Finding case-sensitive matches can be found by binary searching for something that matches insensitively, and then searching around that equivalence class for one that matches.

Inheritance information for the types in this assembly. The mapping is between a type's simple name (like 'IDictionary') and the simple metadata names of types that implement it or derive from it (like 'Dictionary'). Note: to save space, all names in this map are stored with simple ints. These ints are the indices into _nodes that contain the nodes with the appropriate name. This mapping is only produced for metadata assemblies.

Maps the name of receiver type name to its . for the definition of simple/complex methods. For non-array simple types, the receiver type name would be its metadata name, e.g. "Int32". For any array types with simple type as element, the receiver type name would be just "ElementTypeName[]", e.g. "Int32[]" for int[][,] For non-array complex types, the receiver type name is "". For any array types with complex type as element, the receiver type name is "[]"

Finds symbols in this assembly that match the provided name in a fuzzy manner.

Returns if this index contains some symbol that whose name matches case sensitively. otherwise.

Get all symbols that have a name matching the specified name.

Searches for a name in the ordered list that matches per the .

Used to produce the simple-full-name components of a type from metadata. The name is 'simple' in that it does not contain things like backticks, generic arguments, or nested type + separators. Instead just hte name of the type, any containing types, and the component parts of its namespace are added. For example, for the type "X.Y.O`1.I`2, we will produce [X, Y, O, I]

s are produced when initially creating our indices. They store Names of symbols and the index of their parent symbol. When we produce the final though we will then convert these to s.

The Name of this Node.

Index in of the parent Node of this Node. Value will be if this is the Node corresponding to the root symbol.

This is the type name of the parameter when is false. For array types, this is just the element type name. e.g. `int` for `int[][,]`

Indicate if the type of parameter is any kind of array. This is relevant for both simple and complex types. For example: - array of simple type like int[], int[][], int[][,], etc. are all ultimately represented as "int[]" in index. - array of complex type like T[], T[][], etc are all represented as "[]" in index, in contrast to just "" for non-array types.

Similar to , we divide extension methods into simple and complex categories for filtering purpose. Whether a method is simple is determined based on if we can determine it's receiver type easily with a pure text matching. For complex methods, we will need to rely on symbol to decide if it's feasible. Simple types include: - Primitive types - Types which is not a generic method parameter - By reference type of any types above - Array types with element of any types above

Name of the extension method. This can be used to retrieve corresponding symbols via

Fully qualified name for the type that contains this extension method.

Cache the symbol tree infos for assembly symbols produced from a particular . Generating symbol trees for metadata can be expensive (in large metadata cases). And it's common for us to have many threads to want to search the same metadata simultaneously. As such, we use an AsyncLazy to compute the value that can be shared among all callers. We store this keyed off of the produced by . This ensures that

Similar to except that this caches based on metadata id. The primary difference here is that you can have the same MetadataId from two different s, while having different checksums. For example, if the aliases of a are changed (see , then it will have a different checksum, but same metadata ID. As such, we can use this table to ensure we only do the expensive computation of the once per , but we may then have to make a copy of it with a new if the checksums differ.

Produces a for a given . Note: will never return null;

Optional checksum for the (produced by ). Can be provided if already computed. If not provided it will be computed and used for the .

Produces a for a given . Note: will never return null;

Optional checksum for the (produced by ). Can be provided if already computed. If not provided it will be computed and used for the .

Loads any info we have for this reference from our persistence store. Will succeed regardless of the checksum of the . Should only be used by clients that are ok with potentially stale data.

Represent this as non-null because that will be true when this is not in a pool and it is being used by other services.

Only applies to member kind. Represents the type info of the first parameter.

Generalized function for loading/creating/persisting data. Used as the common core code for serialization of source and metadata SymbolTreeInfos.

Loads any info we have for this project from our persistence store. Will succeed regardless of the checksum of the . Should only be used by clients that are ok with potentially stale data.

Cache of project to the checksum for it so that we don't have to expensively recompute this each time we get a project.

Returns true when the identifier is probably (but not guaranteed) to be within the syntax tree. Returns false when the identifier is guaranteed to not be within the syntax tree.

Returns true when the identifier is probably (but not guaranteed) escaped within the text of the syntax tree. Returns false when the identifier is guaranteed to not be escaped within the text of the syntax tree. An identifier that is not escaped within the text can be found by searching the text directly. An identifier that is escaped can only be found by parsing the text and syntactically interpreting any escaping mechanisms found in the language ("\uXXXX" or "@XXXX" in C# or "[XXXX]" in Visual Basic).

Returns true when the identifier is probably (but not guaranteed) to be within the syntax tree. Returns false when the identifier is guaranteed to not be within the syntax tree.

String interning table so that we can share many more strings in our DeclaredSymbolInfo buckets. Keyed off a Project instance so that we share all these strings as we create the or load the index items for this a specific Project. This helps as we will generally be creating or loading all the index items for the documents in a Project at the same time. Once this project is let go of (which happens with any solution change) then we'll dump this string table. The table will have already served its purpose at that point and doesn't need to be kept around further.

Gets the set of global aliases that point to something with the provided name and arity. For example of there is global alias X = A.B.C<int>, then looking up with name="C" and arity=1 will return X.

The name to pattern match against, and to show in a final presentation layer.

An optional suffix to be shown in a presentation layer appended to .

Container of the symbol that can be shown in a final presentation layer. For example, the container of a type "KeyValuePair" might be "System.Collections.Generic.Dictionary<TKey, TValue>". This can then be shown with something like "type System.Collections.Generic.Dictionary<TKey, TValue>" to indicate where the symbol is located.

Dotted container name of the symbol, used for pattern matching. For example The fully qualified container of a type "KeyValuePair" would be "System.Collections.Generic.Dictionary" (note the lack of type parameters). This way someone can search for "D.KVP" and have the "D" part of the pattern match against this. This should not be shown in a presentation layer.

The names directly referenced in source that this type inherits from.

Same as , just stored as a set for easy containment checks.

Name of the extension method's receiver type to the index of its DeclaredSymbolInfo in `_declarationInfo`. For simple types, the receiver type name is it's metadata name. All predefined types are converted to its metadata form. e.g. int => Int32. For generic types, type parameters are ignored. For complex types, the receiver type name is "". For any kind of array types, it's "{element's receiver type name}[]". e.g. int[][,] => "Int32[]" T (where T is a type parameter) => "" T[,] (where T is a type parameter) => "T[]"

Helper comparer to enable consumers of to process references found in linked files only a single time.

Base implementation of C# and VB formatting services.

Formats whitespace in documents or syntax trees.

The annotation used to mark portions of a syntax tree to be formatted.

Gets the formatting rules that would be applied if left unspecified.

Formats the whitespace in a document.

The document to format. An optional set of formatting options. If these options are not supplied the current set of options from the document's workspace will be used. An optional cancellation token. The formatted document.

Formats the whitespace in an area of a document corresponding to a text span.

The document to format. The span of the document's text to format. An optional set of formatting options. If these options are not supplied the current set of options from the document's workspace will be used. An optional cancellation token. The formatted document.

Formats the whitespace in areas of a document corresponding to multiple non-overlapping spans.

The document to format. The spans of the document's text to format. An optional set of formatting options. If these options are not supplied the current set of options from the document's workspace will be used. An optional cancellation token. The formatted document.

Formats the whitespace in areas of a document corresponding to annotated nodes.

The document to format. The annotation used to find on nodes to identify spans to format. An optional set of formatting options. If these options are not supplied the current set of options from the document's workspace will be used. An optional cancellation token. The formatted document.

Formats the whitespace in areas of a syntax tree corresponding to annotated nodes.

The root node of a syntax tree to format. The annotation used to find nodes to identify spans to format. A workspace used to give the formatting context. An optional set of formatting options. If these options are not supplied the current set of options from the workspace will be used. An optional cancellation token. The formatted tree's root node.

Formats the whitespace of a syntax tree.

The root node of a syntax tree to format. A workspace used to give the formatting context. An optional set of formatting options. If these options are not supplied the current set of options from the workspace will be used. An optional cancellation token. The formatted tree's root node.

Formats the whitespace in areas of a syntax tree identified by a span.

The root node of a syntax tree to format. The span within the node's full span to format. A workspace used to give the formatting context. An optional set of formatting options. If these options are not supplied the current set of options from the workspace will be used. An optional cancellation token. The formatted tree's root node.

Formats the whitespace in areas of a syntax tree identified by multiple non-overlapping spans.

The root node of a syntax tree to format. The spans within the node's full span to format. A workspace used to give the formatting context. An optional set of formatting options. If these options are not supplied the current set of options from the workspace will be used. An optional cancellation token. The formatted tree's root node.

Determines the changes necessary to format the whitespace of a syntax tree.

Organizes the imports in the document.

The document to organize. The cancellation token that the operation will observe. The document with organized imports. If the language does not support organizing imports, or if no changes were made, this method returns .

Formats the whitespace in areas of a document corresponding to multiple non-overlapping spans.

The document to format. The spans of the document's text to format. If null, the entire document should be formatted. Line formatting options. Formatting options, if available. Null for non-Roslyn languages. Cancellation token. The formatted document.

Provide a custom formatting operation provider that can intercept/filter/replace default formatting operations.

All methods defined in this class can be called concurrently. Must be thread-safe.

Returns SuppressWrappingIfOnSingleLineOperations under a node either by itself or by filtering/replacing operations returned by NextOperation

returns AnchorIndentationOperations under a node either by itself or by filtering/replacing operations returned by NextOperation

returns IndentBlockOperations under a node either by itself or by filtering/replacing operations returned by NextOperation

returns AlignTokensOperations under a node either by itself or by filtering/replacing operations returned by NextOperation

returns AdjustNewLinesOperation between two tokens either by itself or by filtering/replacing a operation returned by NextOperation

returns AdjustSpacesOperation between two tokens either by itself or by filtering/replacing a operation returned by NextOperation

Returns SuppressWrappingIfOnSingleLineOperations under a node either by itself or by filtering/replacing operations returned by NextOperation

returns AnchorIndentationOperations under a node either by itself or by filtering/replacing operations returned by NextOperation

returns IndentBlockOperations under a node either by itself or by filtering/replacing operations returned by NextOperation

returns AlignTokensOperations under a node either by itself or by filtering/replacing operations returned by NextOperation

returns AdjustNewLinesOperation between two tokens either by itself or by filtering/replacing a operation returned by NextOperation

returns AdjustSpacesOperation between two tokens either by itself or by filtering/replacing a operation returned by NextOperation

indicate how many lines are needed between two tokens

Options for . the operation will leave lineBreaks as it is if original lineBreaks are equal or greater than given lineBreaks the operation will force existing lineBreaks to the given lineBreaks

indicate how many spaces are needed between two spaces

Options for .

Preserve spaces as it is

means a default space operation created by the formatting engine by itself. It has its own option kind to indicates that this is an operation generated by the engine itself.

means forcing the specified spaces between two tokens if two tokens are on a single line.

means forcing the specified spaces regardless of positions of two tokens.

If two tokens are on a single line, second token will be placed at current indentation if possible

align first tokens on lines among the given tokens to the base token

option to control behavior

preserve relative spaces between anchor token and first tokens on lines within the given text span as long as it doesn't have explicit line operations associated with them

create anchor indentation region around start and end token right after anchor token to end of end token will become anchor region

create anchor indentation region more explicitly by providing all necessary information.

create suppress region around start and end token

create suppress region around the given text span

create indent block region around the start and end token with the given indentation delta added to the existing indentation at the position of the start token

create indent block region around the given text span with the given indentation delta added to the existing indentation at the position of the start token

create indent block region around the start and end token with the given indentation delta added to the column of the base token

create indent block region around the given text span with the given indentation delta added to the column of the base token

instruct the engine to try to align first tokens on the lines among the given tokens to be aligned to the base token

instruct the engine to try to put the give lines between two tokens

instruct the engine to try to put the given spaces between two tokens

return AnchorIndentationOperation for the node provided by the given formatting rules

return IndentBlockOperation for the node provided by the given formatting rules

return AlignTokensOperation for the node provided by the given formatting rules

return AdjustNewLinesOperation for the node provided by the given formatting rules

return AdjustSpacesOperation for the node provided by the given formatting rules

set indentation level for the given text span. it can be relative, absolute or dependent to other tokens

Options for .

This indentation will be a delta to the first token in the line in which the base token is present

will be interpreted as delta of its enclosing indentation

will be interpreted as absolute position

Mask for relative position options

Mask for position options.

Each specifies one of the position options to indicate the primary behavior for the operation.

Increase the if the block is part of a condition of the anchor token. For example:


            if (value is
                { // This open brace token is part of a condition of the 'if' token.
                    Length: 2
                })

suppress formatting operations within the given text span

Options for . no wrapping if given tokens are on same line no wrapping regardless of relative positions of two tokens no spacing regardless of relative positions of two tokens

Completely disable formatting within a span.

Automatic (on-type) formatting options.

Formatting options stored in editorconfig.

For use in the shared CodeStyle layer. Keep in syntax with FormattingOptions.IndentStyle.

Default value of 120 was picked based on the amount of code in a github.com diff at 1080p. That resolution is the most common value as per the last DevDiv survey as well as the latest Steam hardware survey. This also seems to a reasonable length default in that shorter lengths can often feel too cramped for .NET languages, which are often starting with a default indentation of at least 16 (for namespace, class, member, plus the final construct indentation). TODO: Currently the option has no storage and always has its default value. See https://github.com/dotnet/roslyn/pull/30422#issuecomment-436118696. Internal option -- not exposed to tooling.

Internal option -- not exposed to editorconfig tooling.

Options that we expect the user to set in editorconfig.

Options that can be set via editorconfig but we do not provide tooling support.

Language agnostic defaults.

a tweaked version of our interval tree to meet the formatting engine's need it now has an ability to return a smallest span that contains a position rather than all Intersecting or overlapping spans

this class maintain contextual information such as indentation of current position, based token to follow in current position and etc.

data that will be used in an interval tree related to Anchor.

data that will be used in an interval tree related to indentation.

Caches the value produced by .

if the field is not yet initialized; otherwise, the value returned from .

Represents an indentation in which a fixed offset () is applied to a reference indentation amount ().

The reference indentation data which needs to be adjusted.

The adjustment to apply to the value providede by .

data that will be used in an interval tree related to suppressing spacing operations.

data that will be used in an interval tree related to suppressing wrapping operations.

rewrite the node with the given trivia information in the map

It is very common to be formatting lots of documents at teh same time, with the same set of formatting rules and options. To help with that, cache the last set of ChainedFormattingRules that was produced, as it is not a cheap type to create.

Stored as a instead of a so we don't have to worry about torn write concerns.

return summary for current formatting work

this actually applies formatting operations to trivia between two tokens

span in the tree to format

rewrite the tree info root node with the trivia information in the map

represents a general trivia between two tokens. slightly more expensive than others since it needs to calculate stuff unlike other cases

this collector gathers formatting operations that are based on a node

it represents a token that is inside of token stream not also outside of token stream it uses an index to navigate previous and after tokens in the stream to make navigation faster. and regular Previous/NextToken for tokens outside of the stream. this object is supposed to be live very short but created a lot of time. that is why it is struct. (same reason why SyntaxToken is struct - to reduce heap allocation)

it holds onto space and wrapping operation need to run between two tokens.

This class takes care of tokens consumed in the formatting engine. It will maintain information changed compared to original token information. and answers information about tokens.

Thread-safe collection that holds onto changes

Get column of the token * column means text position on a line where all tabs are converted to spaces that first position on a line becomes 0

this provides information about the syntax tree formatting service is formatting. this provides necessary abstraction between different kinds of syntax trees so that ones that contain actual text or cache can answer queries more efficiently.

it holds onto trivia information between two tokens

This is the ID reported for formatting diagnostics.

This special diagnostic can be suppressed via #pragma to prevent the formatter from making changes to code formatting within the span where the diagnostic is suppressed.

Contains changes that can be either applied to different targets such as a buffer or a tree or examined to be used in other places such as quick fix.

set up space string caches

format the trivia at the line column and put changes to the changes

create whitespace for the delta at the line column and put changes to the changes

return whether this formatting succeeded or not for example, if there is skipped tokens in one of trivia between tokens we consider formatting this region is failed

check whether given trivia is whitespace trivia or not

check whether given trivia is end of line trivia or not

true if previoustrivia is _ and nextTrivia is a Visual Basic comment

check whether given trivia is a Comment in VB or not It is never reachable in C# since it follows a test for LineContinuation Character.

check whether given string is either null or whitespace

check whether given char is whitespace

check whether given char is new line char

create whitespace trivia

create end of line trivia

return line column rule for the given two trivia

format the given trivia at the line column position and put result to the changes list

format the given trivia at the line column position and put text change result to the changes list

returns true if the trivia contains a Line break

get line column rule between two trivia

if the given trivia is the very first or the last trivia between two normal tokens and if the trivia is structured trivia, get one token that belongs to the structured trivia and one belongs to the normal token stream

check whether string between start and end position only contains whitespace

check whether first line between two tokens contains only whitespace

return 0 or 1 based on line column of the trivia1's end point this is based on our structured trivia's implementation detail that some structured trivia can have one new line at the end of the trivia

absolute line number from first token

absolute column from beginning of a line

there is only whitespace on this line

relative line number between calls

relative spaces between calls

there is only whitespace in this space

force text change regardless line and space changes

Get the name of the target type of specified extension method declaration. The node provided must be an extension method declaration, i.e. calling `TryGetDeclaredSymbolInfo()` on `node` should return a `DeclaredSymbolInfo` of kind `ExtensionMethod`. If the return value is null, then it means this is a "complex" method (as described at ).

Provides helpers for working across "blocks" of statements in an agnostic fashion across VB and C#. Both languages have quirks here that this API attempts to smooth out. For example, many things in VB are 'blocks' (like ClassBlocks and MethodBlocks). However, only a subset of those can have executable statements. Similarly, C# has actual BlockSyntax nodes ({ ... }), but it can also have sequences of executable statements not contained by those (for example statements in a case-clause in a switch-statement).

A block that has no semantics other than introducing a new scope. That is only C# BlockSyntax.

Gets the directly parenting block for the statement if it has one. For C#, this is the direct parent BlockSyntax, SwitchSectionSyntax, or CompilationUnit if the statement is parented by a GlobalStatementSyntax. This returns for any other cases (like an embedded statement).

If this returns a parent value then the will always be found within the statements returned by on that value

A node that contains a list of statements. In C#, this is BlockSyntax, SwitchSectionSyntax and CompilationUnitSyntax. In VB, this includes all block statements such as a MultiLineIfBlockSyntax.

A node that can host a list of statements or a single statement. In addition to every "executable block", this also includes C# embedded statement owners.

Gets the statement container node for the statement .

The statement container for .

Checks if the position is on the header of a type (from the start of the type up through it's name).

Tries to get an ancestor of a Token on current position or of Token directly to left: e.g.: tokenWithWantedAncestor[||]tokenWithoutWantedAncestor

Returns whether a given declaration can have accessibility or not.

The declaration node to check A flag that indicates whether to consider modifiers on the given declaration that blocks adding accessibility.

True if this language supports implementing an interface by signature only. If false, implementations must specific explicitly which symbol they're implementing.

True if anonymous functions in this language have signatures that include named parameters that can be referenced later on when the function is invoked. Or, if the anonymous function is simply a signature that will be assigned to a delegate, and the delegate's parameter names are used when invoking. For example, in VB one can do this: dim v = Sub(x as Integer) Blah() v(x:=4) However, in C# that would need to be: Action<int> v = (int x) => Blah(); v(obj:=4) Note that in VB one can access 'x' outside of the declaration of the anonymous type. While in C# 'x' can only be accessed within the anonymous type.

True if a write is performed to the given expression. Note: reads may also be performed to the expression as well. For example, "++a". In this expression 'a' is both read from and written to.

True if a write is performed to the given expression. Note: unlike IsWrittenTo, this will not return true if reads are performed on the expression as well. For example, "++a" will return 'false'. However, 'a' in "out a" or "a = 1" will return true.

return speculative semantic model for supported node. otherwise, it will return null

get all alias names defined in the semantic model

Finds all local function definitions within the syntax references for a given

Gets the that the given node involves. The node's kind must match any of the following kinds: , , or .

Given a location in a document, returns the symbol that intercepts the original symbol called at that location. The position must be the location of an identifier token used as the name of an invocation expression.

controls how much of the type header should be considered. If only the span up through the type name will be considered. If then the span through the base-list will be considered.

Contains helpers to allow features and other algorithms to run over C# and Visual Basic code in a uniform fashion. It should be thought of a generalized way to apply type-pattern-matching and syntax-deconstruction in a uniform fashion over the languages. Helpers in this type should only be one of the following forms: 'IsXXX' where 'XXX' exactly matches one of the same named syntax (node, token, trivia, list, etc.) constructs that both C# and VB have. For example 'IsSimpleName' to correspond to C# and VB's SimpleNameSyntax node. These 'checking' methods should never fail. For non leaf node types this should be implemented as a typecheck ('is' in C#, 'typeof ... is' in VB). For leaf nodes, this should be implemented by deffering to to check against the raw kind of the node. 'GetPartsOfXXX(SyntaxNode node, out SyntaxNode/SyntaxToken part1, ...)' where 'XXX' one of the same named Syntax constructs that both C# and VB have, and where the returned parts correspond to the members those nodes have in common across the languages. For example 'GetPartsOfQualifiedName(SyntaxNode node, out SyntaxNode left, out SyntaxToken dotToken, out SyntaxNode right)' VB. These functions should throw if passed a node that the corresponding 'IsXXX' did not return for. For nodes that only have a single child, 'GetPartsOfXXX' is not not needed and can be replaced with the easier to use 'GetXXXOfYYY' to get that single child. 'GetXxxOfYYY' where 'XXX' matches the name of a property on a 'YYY' syntax construct that both C# and VB have. For example 'GetExpressionOfMemberAccessExpression' corresponding to MemberAccessExpressionsyntax.Expression in both C# and VB. These functions should throw if passed a node that the corresponding 'IsYYY' did not return for. For nodes that only have a single child, these functions can stay here. For nodes with multiple children, these should migrate to and be built off of 'GetPartsOfXXX'. Absolutely trivial questions that relate to syntax and can be asked sensibly of each language. For example, if certain constructs (like 'patterns') are supported in that language or not. Importantly, avoid: Functions that attempt to blur the lines between similar constructs in the same language. For example, a QualifiedName is not the same as a MemberAccessExpression (despite A.B being representable as either depending on context). Features that need to handle both should make it clear that they are doing so, showing that they're doing the right thing for the contexts each can arise in (for the above example in 'type' vs 'expression' contexts). Functions which are effectively specific to a single feature are are just trying to find a place to place complex feature logic in a place such that it can run over VB or C#. For example, a function to determine if a position is on the 'header' of a node. a 'header' is a not a well defined syntax concept that can be trivially asked of nodes in either language. It is an excapsulation of a feature (or set of features) level idea that should be in its own dedicated service. Functions that mutate or update syntax constructs for example 'WithXXX'. These should be on SyntaxGenerator or some other feature specific service. Functions that a single item when one language may allow for multiple. For example 'GetIdentifierOfVariableDeclarator'. In VB a VariableDeclarator can itself have several names, so calling code must be written to check for that and handle it apropriately. Functions like this make it seem like that doesn't need to be considered, easily allowing for bugs to creep in. Abbreviating or otherwise changing the names that C# and VB share here. For example use 'ObjectCreationExpression' not 'ObjectCreation'. This prevents accidental duplication and keeps consistency with all members.

Many helpers in this type currently violate the above 'dos' and 'do nots'. They should be removed and either inlined directly into the feature that needs if (if only a single feature), or moved into a dedicated service for that purpose if needed by multiple features.

Returns 'true' if this a 'reserved' keyword for the language. A 'reserved' keyword is a identifier that is always treated as being a special keyword, regardless of where it is found in the token stream. Examples of this are tokens like and in C# and VB respectively. Importantly, this does *not* include contextual keywords. If contextual keywords are important for your scenario, use or . Also, consider using if all you need is the ability to know if this is effectively any identifier in the language, regardless of whether the language is treating it as a keyword or not.

Returns if this a 'contextual' keyword for the language. A 'contextual' keyword is a identifier that is only treated as being a special keyword in certain *syntactic* contexts. Examples of this is 'yield' in C#. This is only a keyword if used as 'yield return' or 'yield break'. Importantly, identifiers like , and are *not* 'contextual' keywords. This is because they are not treated as keywords depending on the syntactic context around them. Instead, the language always treats them identifiers that have special *semantic* meaning if they end up not binding to an existing symbol. Importantly, if is not in the syntactic construct where the language thinks an identifier should be contextually treated as a keyword, then this will return . Or, in other words, the parser must be able to identify these cases in order to be a contextual keyword. If identification happens afterwards, it's not contextual.

The set of identifiers that have special meaning directly after the `#` token in a preprocessor directive. For example `if` or `pragma`.

Get the node on the left side of the dot if given a dotted expression.

In VB, we have a member access expression with a null expression, this may be one of the following forms: 1) new With { .a = 1, .b = .a .a refers to the anonymous type 2) With obj : .m .m refers to the obj type 3) new T() With { .a = 1, .b = .a 'a refers to the T type If `allowImplicitTarget` is set to true, the returned node will be set to approperiate node, otherwise, it will return null. This parameter has no affect on C# node.

Gets the containing expression that is actually a language expression and not just typed as an ExpressionSyntax for convenience. For example, NameSyntax nodes on the right side of qualified names and member access expressions are not language expressions, yet the containing qualified names or member access expressions are indeed expressions.

Call on the `.y` part of a `x?.y` to get the entire `x?.y` conditional access expression. This also works when there are multiple chained conditional accesses. For example, calling this on '.y' or '.z' in `x?.y?.z` will both return the full `x?.y?.z` node. This can be used to effectively get 'out' of the RHS of a conditional access, and commonly represents the full standalone expression that can be operated on atomically.

Returns the expression node the member is being accessed off of. If is , this will be the node directly to the left of the dot-token. If is , then this can return another node in the tree that the member will be accessed off of. For example, in VB, if you have a member-access-expression of the form ".Length" then this may return the expression in the surrounding With-statement.

True if this is an argument with just an expression and nothing else (i.e. no ref/out, no named params, no omitted args).

Returns true for nodes that represent the body of a method. For VB this will be MethodBlockBaseSyntax. This will be true for things like constructor, method, operator bodies as well as accessor bodies. It will not be true for things like sub() function() lambdas. For C# this will be the BlockSyntax or ArrowExpressionSyntax for a method/constructor/deconstructor/operator/accessor. It will not be included for local functions.

Returns true if the given character is a character which may be included in an identifier to specify the type of a variable.

Given a , return the representing the span of the member body it is contained within. This is used to determine whether speculative binding should be used in performance-critical typing scenarios. Note: if this method fails to find a relevant span, it returns an empty at position 0.

Returns the parent node that binds to the symbols that the IDE prefers for features like Quick Info and Find All References. For example, if the token is part of the type of an object creation, the parenting object creation expression is returned so that binding will return constructor symbols.

Given a , that represents and argument return the string representation of that arguments name.

Given a , that represents an attribute argument return the string representation of that arguments name.

Determines if there is preprocessor trivia *between* any of the provided. The will be deduped and then ordered by position. Specifically, the first token will not have it's leading trivia checked, and the last token will not have it's trailing trivia checked. All other trivia will be checked to see if it contains a preprocessor directive.

Similar to , this gets the containing expression that is actually a language expression and not just typed as an ExpressionSyntax for convenience. However, this goes beyond that that method in that if this expression is the RHS of a conditional access (i.e. a?.b()) it will also return the root of the conditional access expression tree. The intuition here is that this will give the topmost expression node that could realistically be replaced with any other expression. For example, with a?.b() technically .b() is an expression. But that cannot be replaced with something like (1 + 1) (as a?.(1 + 1) is not legal). However, in a?.b(), then a itself could be replaced with (1 + 1)?.b() to form a legal expression.

Provides a uniform view of SyntaxKinds over C# and VB for constructs they have in common.

Gets the syntax kind for a multi-line comment.

The raw syntax kind for a multi-line comment; otherwise, if the language does not support multi-line comments.

Provides a uniform view of SyntaxKinds over C# and VB for constructs they have in common.

Helper service for telling you what type can be inferred to be viable in a particular location in code. This is useful for features that are starting from code that doesn't bind, but would like to know type that code should be in the location that it can be found in. For example: int i = Here(); If 'Here()' doesn't bind, then this class can be used to say that it is currently in a location whose type has been inferred to be 'int' from the surrounding context. Note: this is simply a best effort guess. 'byte/short/etc.' as well as any user convertible types to int would also be valid here, however 'int' seems the most reasonable when considering user intuition.

Retrieves all symbols that could collide with a symbol at the specified location. A symbol can possibly collide with the location if it is available to that location and/or could cause a compiler error if its name is re-used at that location.

Given a symbol in source, returns the syntax nodes that compromise its declarations. This differs from symbol.Locations in that Locations returns a list of ILocations that normally correspond to the name node of the symbol.

helper class to aggregate some numeric value log in client side

The key here is an object even though we will often be putting enums into this map; the problem with the use of enums or other value types is they prevent the runtime from sharing the same JITted code for each different generic instantiation. In this case, the cost of boxing is cheaper than the cost of the extra JIT.

a logger that aggregate multiple loggers

a logger that doesn't do anything

A logger that publishes events to ETW using an EventSource.

Defines a log aggregator to create a histogram

Writes out these statistics to a property bag for sending to telemetry.

The prefix given to any properties written. A period is used to delimit between the prefix and the value.

An interaction class defines how much time is expected to reach a time point, the response time point being the most commonly used. The interaction classes correspond to human perception, so, for example, all interactions in the Fast class are perceived as fast and roughly feel like they have the same performance. By defining these interaction classes, we can describe performance using adjectives that have a precise, consistent meaning.

LogMessage that creates key value map lazily

Creates a with default , since KV Log Messages are by default more informational and should be logged as such.

Type of log it is making.

Log some traces of an activity (default)

Log an user explicit action

Represents telemetry data that's classified as personally identifiable information.

This EventSource exposes our events to ETW. RoslynEventSource GUID is {bf965e67-c7fb-5c5b-d98f-cdf68f8154c2}. When updating this class, use the following to also update Main\Source\Test\Performance\Log\RoslynEventSourceParser.cs: Main\Tools\Source\TraceParserGen\bin\Debug\TraceParserGen.exe Microsoft.CodeAnalysis.Workspaces.dll -eventsource:RoslynEventSource Use this command to register the ETW manifest on any machine where you need to decode events in xperf/etlstackbrowse: "\\clrmain\tools\managed\etw\eventRegister\bin\Debug\eventRegister.exe" Microsoft.CodeAnalysis.Workspaces.dll

Logs an informational block with given 's representation as the message and specified . On dispose of the returned disposable object, it logs the 'tick' count between the start and end of the block. Unlike other logging methods on , this method does not check if the specified was explicitly enabled. Instead it checks if the was enabled at level.

Logs an informational message block with the given > and specified . On dispose of the returned disposable object, it logs the 'tick' count between the start and end of the block. Unlike other logging methods on , this method does not check if the specified was explicitly enabled. Instead it checks if the was enabled at level.

This tracks the logged message. On instantiation, it logs 'Started block' with other event data. On dispose, it logs 'Ended block' with the same event data so we can track which block started and ended when looking at logs.

next unique block id that will be given to each LogBlock

return next unique pair id

maximum value

minimum value

average value of the total data set

most frequent value in the total data set

difference between max and min value

number of data points in the total data set

Writes out these statistics to a property bag for sending to telemetry.

The prefix given to any properties written. A period is used to delimit between the prefix and the value.

Implementation of that produce timing debug output.

no op log block

Enum to uniquely identify each function location.

logger interface actual logger should implements

answer whether it is enabled or not for the specific function id

log a specific event with context message

log a start event with context message

log an end event

provide a way to log activities to various back end such as etl, code marker and etc

next unique block id that will be given to each LogBlock

give a way to explicitly set/replace the logger

ensure we have a logger by putting one from workspace service if one is not there already.

log a specific event with a simple context message which should be very cheap to create

log a specific event with a context message that will only be created when it is needed. the messageGetter should be cheap to create. in another word, it shouldn't capture any locals

log a specific event with a context message that requires some arguments to be created when requested. given arguments will be passed to the messageGetter so that it can create the context message without requiring lifted locals

log a specific event with a context message.

return next unique pair id

simplest way to log a start and end pair

simplest way to log a start and end pair with a simple context message which should be very cheap to create

log a start and end pair with a context message that will only be created when it is needed. the messageGetter should be cheap to create. in another word, it shouldn't capture any locals

log a start and end pair with a context message that requires some arguments to be created when requested. given arguments will be passed to the messageGetter so that it can create the context message without requiring lifted locals

log a start and end pair with a context message.

Defines logging severity levels. Each logger may choose to report differently based on the level of the message being logged. Copied from Microsoft.Extensions.Logging https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel

Logs that contain the most detailed messages. These messages may contain sensitive application data. These messages are disabled by default and should never be enabled in a production environment.

Logs that are used for interactive investigation during development. These logs should primarily contain information useful for debugging and have no long-term value.

Logs that track the general flow of the application. These logs should have long-term value.

Logs that highlight an abnormal or unexpected event in the application flow, but do not otherwise cause the application execution to stop.

Logs that highlight when the current flow of execution is stopped due to a failure. These should indicate a failure in the current activity, not an application-wide failure.

Logs that describe an unrecoverable application or system crash, or a catastrophic failure that requires immediate attention.

Not used for writing log messages. Specifies that a logging category should not write any messages.

log message that can generate string lazily

Logger will call this to return LogMessage to its pool

Optional interface that can be used to hear about when expensive global operations (like a 'build') occur in the current host.

raised when global operation is started

raised when global operation is stopped

start new global operation

The of the keyword in Visual Basic, or for C# scenarios. This value is used to improve performance in the token classification fast-path by avoiding unnecessary calls to .

Service which can analyze a span of a document and identify all locations of declarations or references to symbols which are marked .

An that comes from . It behaves just like a normal but remembers which language the is, so you don't have to pass that information redundantly when calling .

Cached internal values read from or .

Creates a new that contains the changed value.

Gets the value of the option, or the default value if not otherwise set.

Creates a new that contains the changed value.

Gets the value of the option, or the default value if not otherwise set.

Creates a new that contains the changed value.

Checks if the value is an internal representation -- does not cover all cases, just code style options.

Checks if the value is an public representation -- does not cover all cases, just code style options.

Provides services for reading and writing global client (in-proc) options shared across all workspaces.

Gets the current value of the specific option.

Gets the current values of specified options. All options are read atomically.

Sets and persists the value of a global option. Sets the value of a global option. Invokes registered option persisters. Triggers option changed event for handlers registered with .

Atomically sets the values of specified global options. The option values are persisted. Triggers option changed event for handlers registered with .

Returns true if any option changed its value stored in the global options.

Refreshes the stored value of an option. This should only be called from persisters. Does not persist the new option value.

Returns true if the option changed its value stored in the global options.

Enables legacy APIs to access global options from workspace. Not available OOP. Only use in client code and when IGlobalOptionService can't be MEF imported.

Only used by and to implement legacy public APIs: and .

Exportable by a host to specify the save and restore behavior for a particular set of values.

Gets the . If the persister does not already exist, it is created.

This method is safe for concurrent use from any thread. No guarantees are made regarding the use of the UI thread. A cancellation token the operation may observe. The option persister.

Stores options that are not defined by Roslyn and do not implement .

Sets values of options that may be stored in (public options). Clears of registered workspaces so that next time are queried for the options new values are fetched from .

The base type of all types that specify where options are stored.

The name of the providers for .editorconfig. Both the current and legacy providers will use this name, so that way any other clients can order relative to the pair. The two factories are unordered themselves because only one ever actually gives a real provider.

Implements in-proc only storage for . Supports tracking changed options. Options that are not set in the option set are read from global options and cached.

Cached values read from global options. Stores internal values of options.

Keys of options whose current value stored in differs from the value originally read from global options.

Some options store their values in a type that's not accessible publicly. The mapping provides translation between the two representations.

The option that stores the value internally.

Converts internal option value representation to public.

Returns a new internal value created by updating to .

Interface implemented by public options (Option and PerLanguageOption) to distinguish them from internal ones ( and ).

Creates a serializer for an enum value that uses the enum field names.

Creates a serializer for an enum value given a between value names and the corresponding enum values.

Creates a serializer for an enum value given a between value names and the corresponding enum values. specifies alternative value representations for backward compatibility.

Serializes arbitrary editorconfig option value (including naming style preferences) into a given builder. Replaces existing value if present.

Specifies that an option should be read from an .editorconfig file.

Gets the editorconfig string representation for the specified .

Internal base option type that is available in both the Workspaces layer and CodeStyle layer. Its definition in Workspaces layer sub-types "IOption" and its definition in CodeStyle layer explicitly defines all the members from "IOption" type as "IOption" is not available in CodeStyle layer. This ensures that all the sub-types of in either layer see an identical set of interface members.

Group/sub-feature associated with an option.

Optional parent group.

A localizable resource description string for the option group.

Name of the option group

Relative priority of the option group with respect to other option groups within the same feature.

Optional group/sub-feature for this option.

A unique name of the option used in editorconfig.

True if the value of the option may be stored in an editorconfig file.

Mapping between the public option storage and internal option storage.

The untyped/boxed default value of the option.

The type of the option value.

Marker interface for options that has the same value for all languages.

The language name that supports this option, or null if it's supported by multiple languages.

This is an optional metadata used for: Analyzer id to option mapping, used (for example) by configure code-style code action EditorConfig UI to determine whether to put this option under [*.cs], [*.vb], or [*.{cs,vb}] Note that this property is not (and should not be) used for computing option values or storing options.

Marker interface for . This option may apply to multiple languages, such that the option can have a different value for each language.

An option that can be specified once per language.

Attempts to get the package sources applicable to the workspace. Note: this call is made on a best effort basis. If the results are not available (for example, they have not been computed, and doing so would require switching to the UI thread), then an empty array can be returned.

A collection of package sources.

The pattern matcher is not thread-safe. Do not use the pattern matcher across mutiple threads concurrently. It also keeps an internal cache of data for speeding up operations. As such, it should be disposed when done to release the cached data back. and release the matcher appropriately once you no longer need it. Also, while the pattern matcher is culture aware, it uses the culture specified in the constructor.

Encapsulated matches responsible for matching an all lowercase pattern against a candidate using CamelCase matching. i.e. this code is responsible for finding the match between "cofipro" and "CodeFixProvider".

Returns null if no match was found, 1 if a contiguous match was found, 2 if a match as found that starts at the beginning of the candidate, and 3 if a contiguous match was found that starts at the beginning of the candidate.

Updates the currently stored 'best result' if the current result is better. Returns 'true' if no further work is required and we can break early, or 'false' if we need to keep on going. If 'weight' is better than 'bestWeight' and matchSpanToAdd is not null, then matchSpanToAdd will be added to matchedSpansInReverse.

Construct a new PatternMatcher using the specified culture.

The culture to use for string searching and comparison. Whether or not the matching parts of the candidate should be supplied in results. Whether or not close matches should count as matches.

Internal helper for MatchPatternInternal

PERF: Designed to minimize allocations in common cases. If there's no match, then null is returned. If there's a single match, or the caller only wants the first match, then it is returned (as a Nullable) If there are multiple matches, and the caller wants them all, then a List is allocated. The word being tested. The segment of the pattern to check against the candidate. The result array to place the matches in. If a fuzzy match should be performed If there's only one match, then the return value is that match. Otherwise it is null.

Do the two 'parts' match? i.e. Does the candidate part start with the pattern part?

The candidate text The span within the text The pattern text The span within the text Options for doing the comparison (case sensitive or not) True if the span identified by within starts with the span identified by within .

Does the given part start with the given pattern?

The candidate text The span within the text The pattern text Options for doing the comparison (case sensitive or not) True if the span identified by within starts with

First we break up the pattern given by dots. Each portion of the pattern between the dots is a 'Segment'. The 'Segment' contains information about the entire section of text between the dots, as well as information about any individual 'Words' that we can break the segment into.

Information about a chunk of text from the pattern. The chunk is a piece of text, with cached information about the character spans within in. Character spans separate out capitalized runs and lowercase runs. i.e. if you have AAbb, then there will be two character spans, one for AA and one for BB.

Character spans separate out capitalized runs and lowercase runs. i.e. if you have AAbb, then there will be two character spans, one for AA and one for BB.

Not readonly as this value caches data within it, and so it needs to be able to mutate.

Determines if a given candidate string matches under a multiple word query text, as you would find in features like Navigate To.

If this was a match, a set of match types that occurred while matching the patterns. If it was not a match, it returns null.

The type of match that occurred.

True if this was a case sensitive match.

The spans in the original text that were matched. Only returned if the pattern matcher is asked to collect these spans.

Note(cyrusn): this enum is ordered from strongest match type to weakest match type.

The candidate string matched the pattern exactly.

The pattern was a prefix of the candidate string.

The pattern was a substring of the candidate string, but in a way that wasn't a CamelCase match. The pattern had to have at least one non lowercase letter in it, and the match needs to be case sensitive. This will match 'savedWork' against 'FindUnsavedWork'.

The pattern was a substring of the candidate string, starting at a word within that candidate. The pattern can be all lowercase here. This will match 'save' or 'Save' in 'FindSavedWork'

All camel-humps in the pattern matched a camel-hump in the candidate. All camel-humps in the candidate were matched by a camel-hump in the pattern. Example: "CFPS" matching "CodeFixProviderService" Example: "cfps" matching "CodeFixProviderService" Example: "CoFiPrSe" matching "CodeFixProviderService"

All camel-humps in the pattern matched a camel-hump in the candidate. The first camel-hump in the pattern matched the first camel-hump in the candidate. There was no gap in the camel- humps in the candidate that were matched. Example: "CFP" matching "CodeFixProviderService" Example: "cfp" matching "CodeFixProviderService" Example: "CoFiPRo" matching "CodeFixProviderService"

All camel-humps in the pattern matched a camel-hump in the candidate. The first camel-hump in the pattern matched the first camel-hump in the candidate. There was at least one gap in the camel-humps in the candidate that were matched. Example: "CP" matching "CodeFixProviderService" Example: "cp" matching "CodeFixProviderService" Example: "CoProv" matching "CodeFixProviderService"

All camel-humps in the pattern matched a camel-hump in the candidate. The first camel-hump in the pattern did not match the first camel-hump in the pattern. There was no gap in the camel- humps in the candidate that were matched. Example: "FP" matching "CodeFixProviderService" Example: "fp" matching "CodeFixProviderService" Example: "FixPro" matching "CodeFixProviderService"

All camel-humps in the pattern matched a camel-hump in the candidate. The first camel-hump in the pattern did not match the first camel-hump in the pattern. There was at least one gap in the camel-humps in the candidate that were matched. Example: "FS" matching "CodeFixProviderService" Example: "fs" matching "CodeFixProviderService" Example: "FixSer" matching "CodeFixProviderService"

The pattern matches the candidate in a fuzzy manner. Fuzzy matching allows for a certain amount of misspellings, missing words, etc. See for more details.

The pattern was a substring of the candidate and wasn't either or . This can happen when the pattern is allow lowercases and matches some non word portion of the candidate. For example, finding 'save' in 'GetUnsavedWork'. This will not match across word boundaries. i.e. it will not match 'save' to 'VisaVerify' even though 'saVe' is in that candidate.

Represents the progress of an operation. Commonly used to update a UI visible to a user when a long running operation is happening.

Used when bridging from an api that does not show progress to the user to an api that can update progress if available. This should be used sparingly. Locations that currently do not show progress should ideally be migrated to ones that do so that long running operations are visible to the user in a coherent fashion.

When passed to an appropriate , will updates the UI showing the progress of the current operation to the specified .

progress.Report(CodeAnalysisProgress.Description("Renaming files"));

When passed to an appropriate , will add the requested number of incomplete items to the UI showing the progress of the current operation. This is commonly presented with a progress bar. An optional can also be provided to update the UI accordingly (see ).

The number of incomplete items left to perform. Optional description to update the UI to. progress.Report(CodeAnalysisProgress.AddIncompleteItems(20));

When passed to an appropriate , will indicate that some items of work have transitioned from being incomplete (see to complete. This is commonly presented with a progress bar. An optional can also be provided to update the UI accordingly (see ).

The number of items that were completed. Must be greater than or equal to 1. Optional description to update the UI to. progress.Report(CodeAnalysisProgress.CompleteItem());

When passed to an appropriate , will indicate that all progress should be reset for the current operation. This is normally done when the code action is performing some new phase and wishes for the UI progress bar to restart from the beginning.

Currently internal as only roslyn needs this in the impl of our suggested action (we use a progress bar to compute the work, then reset the progress to apply all the changes). Could be exposed later to 3rd party code if a demonstrable need is presented.

Service which can analyze a span of a document and identify all locations of parameters or locals that are ever reassigned. Note that the locations provided are not the reassignment points. Rather if a local or parameter is ever reassigned, these are all the locations of those locals or parameters within that span.

Tries to get a type of its' lambda parameter of argument for each candidate symbol.

symbols corresponding to or Here, some_args can be multi-variables lambdas as well, e.g. f((a,b) => a+b, (a,b,c)=>a*b*c.Length) ordinal of the arguments of function: (a,b) or (a,b,c) in the example above ordinal of the lambda parameters, e.g. a, b or c.

If container is a tuple type, any of its tuple element which has a friendly name will cause the suppression of the corresponding default name (ItemN). In that case, Rest is also removed.

The named symbols to recommend.

The unnamed symbols to recommend. For example, operators, conversions and indexers.

Returns a that a user can use to communicate with a remote host (i.e. ServiceHub)

Get to current RemoteHost

Allows a caller to wait until the remote host client is is first create, without itself kicking off the work to spawn the remote host and make the client itself.

Token signaled when the host starts to shut down.

Keeps alive this solution in the OOP process until the cancellation token is triggered. Used so that long running features (like 'inline rename' or 'lightbulbs') we can call into oop several times, with the same snapshot, knowing that things will stay hydrated and alive on the OOP side. Importantly, by keeping the same snapshot alive on the OOP side, computed attached values (like s) will stay alive as well.

Creates a session between the host and OOP, effectively pinning this until is called on it. By pinning the solution we ensure that all calls to OOP for the same solution during the life of this session do not need to resync the solution. Nor do they then need to rebuild any compilations they've already built due to the solution going away and then coming back.

The is not strictly necessary for this type. This class functions just as an optimization to hold onto data so it isn't resync'ed or recomputed. However, we still want to let the system know when unobserved async work is kicked off in case we have any tooling that keep track of this for any reason (for example for tracking down problems in testing scenarios). This synchronous entrypoint should be used only in contexts where using the async is not possible (for example, in a constructor).

This represents client in client/server model. user can create a connection to communicate with the server (remote host) through this client

Equivalent to except that only the project (and its dependent projects) will be sync'ed to the remote host before executing. This is useful for operations that don't every do any work outside of that project-cone and do not want to pay the high potential cost of a full sync.

Client-side object that is called back from the server when options for a certain language are required. Can be used when the remote API does not have an existing callback. If it does it can implement itself.

Abstracts a connection to a service implementing type .

Remote interface type of the service.

Given two solution snapshots ( and ), determines the set of document text changes necessary to convert to .

Applies the result of to to produce a solution textually equivalent to the newSolution passed to .

Enables logging of using loggers of the specified .

Initializes telemetry session.

Sets for the process. Called as soon as the remote process is created but can't guarantee that solution entities (projects, documents, syntax trees) have not been created beforehand.

Process ID of the remote process.

This deal with serializing/deserializing language specific data

Interface for services that support dumping their contents to memory-mapped-files (generally speaking, our assembly reference objects). This allows those objects to expose the memory-mapped-file info needed to read that data back in in any process.

Represents a which can be serialized for sending to another process. The text is not required to be a live object in the current process, and can instead be held in temporary storage accessible by both processes.

The storage location for .

Exactly one of or will be non-.

The in the current process.

Weak reference to a SourceText computed from . Useful so that if multiple requests come in for the source text, the same one can be returned as long as something is holding it alive.

Checksum of the contents (see ) of the text.

Returns the strongly referenced SourceText if we have it, or tries to retrieve it from the weak reference if it's still being held there.

A that wraps a and provides access to the text in a deferred fashion. In practice, during a host and OOP sync, while all the documents will be 'serialized' over to OOP, the actual contents of the documents will only need to be loaded depending on which files are open, and thus what compilations and trees are needed. As such, we want to be able to lazily defer actually getting the contents of the text until it's actually needed. This loader allows us to do that, allowing the OOP side to simply point to the segments in the memory-mapped-file the host has dumped its text into, and only actually realizing the real text values when they're needed.

Documents should always hold onto instances of this text loader strongly. In other words, they should load from this, and then dump the contents into a RecoverableText object that then dumps the contents to a memory mapped file within this process. Doing that is pointless as the contents of this text are already in a memory mapped file on the host side.

serialize and deserialize objects to stream. some of these could be moved into actual object, but putting everything here is a bit easier to find I believe.

Allow analyzer tests to exercise the oop codepaths, even though they're referring to in-memory instances of DiagnosticAnalyzers. In that case, we'll just share the in-memory instance of the analyzer across the OOP boundary (which still runs in proc in tests), but we will still exercise all codepaths that use the RemoteClient as well as exercising all codepaths that send data across the OOP boundary. Effectively, this allows us to pretend that a is a during tests.

Required information passed with an asset synchronization request to tell the host where to scope the request to. In particular, this is often used to scope to a particular or to avoid having to search the entire solution.

Special instance, allowed only in tests/debug-asserts, that can do a full lookup across the entire checksum tree. Should not be used in normal release-mode product code.

If not null, the search should only descend into the single project with this id.

If not null, the search should only descend into the single document with this id.

Searches only for information about this project.

Searches only for information about this document.

Searches the requested project, and all documents underneath it. Used only in tests.

Searches all documents within the specified project.

Search solution-compilation-state level information.

Search solution-state level information.

Search projects for results. All project-level information will be searched.

Search documents for results.

A wrapper around an array of s, which also combines the value into a single aggregate checksum exposed through .

Aggregate checksum produced from all the constituent checksums in .

Enumerates the child checksums (found in ) that make up this collection. This is equivalent to directly enumerating the property. Importantly, is not part of this enumeration. is the checksum produced by all those child checksums.

A paired list of s, and the checksums for their corresponding 's .

A paired list of s, and the checksums for their corresponding 's and checksums.

Checksums of the SourceTexts of the frozen documents directly. Not checksums of their DocumentStates.

The particular if this was a checksum tree made for a particular project cone. The particular if this was a checksum tree made for a particular project cone.

hold onto object checksum that currently doesn't have a place to hold onto checksum

The core data structure of the tracker. This is a dictionary of variable name to the current identifier tokens that are declaring variables. This should only ever be updated via the AddIdentifier and RemoveIdentifier helpers.

Performs the renaming of the symbol in the solution, identifies renaming conflicts and automatically resolves them where possible.

The new name of the identifier Used after renaming references. References that now bind to any of these symbols are not considered to be in conflict. Useful for features that want to rename existing references to point at some existing symbol. Normally this would be a conflict, but this can be used to override that behavior. The cancellation token. A conflict resolution containing the new solution.

Finds any conflicts that would arise from using as the new name for a symbol and returns how to resolve those conflicts. Will not cross any process boundaries to do this.

Used to find the symbols associated with the Invocation Expression surrounding the Token

Computes an adds conflicts relating to declarations, which are independent of location-based checks. Examples of these types of conflicts include renaming a member to the same name as another member of a type: binding doesn't change (at least from the perspective of find all references), but we still need to track it.

Gives the First Location for a given Symbol by ordering the locations using DocumentId first and Location starting position second

Helper class to track the state necessary for finding/resolving conflicts in a rename session.

Find conflicts in the new solution

Gets the list of the nodes that were annotated for a conflict check

The method determines the set of documents that need to be processed for Rename and also determines the possible set of names that need to be checked for conflicts. The list will contains Strings like Bar -> BarAttribute ; Property Bar -> Bar , get_Bar, set_Bar

We try to rewrite all locations that are invalid candidate locations. If there is only one location it must be the correct one (the symbol is ambiguous to something else) and we always try to rewrite it. If there are multiple locations, we only allow it if the candidate reason allows for it).

We try to compute the sub-spans to rename within the given . If we are renaming within a string, the locations to rename are always within this containing string location and we can identify these sub-spans. However, if we are renaming within a comment, the rename locations can be anywhere in trivia, so we return null and the rename rewriter will perform a complete regex match within comment trivia and rename all matches instead of specific matches.

The result of the conflict engine. Can be made immutable by calling .

The base workspace snapshot

Whether the text that was resolved with was even valid. This may be false if the identifier was not valid in some language that was involved in the rename.

The original text that is the rename replacement.

The solution snapshot as it is being updated with specific rename steps.

Gives information about an identifier span that was affected by Rename (Reference or Non reference)

The Span of the original identifier if it was in source, otherwise the span to check for implicit references. If there was a conflict at ConflictCheckSpan during rename, then the next phase in rename uses ComplexifiedTargetSpan span to be expanded to resolve the conflict.

Gives information about an identifier span that was affected by Rename (Reference or Non reference)

The Span of the original identifier if it was in source, otherwise the span to check for implicit references.

If there was a conflict at ConflictCheckSpan during rename, then the next phase in rename uses ComplexifiedTargetSpan span to be expanded to resolve the conflict.

There was no conflict.

A conflict was resolved at a location that references the symbol being renamed.

A conflict was resolved in a piece of code that does not reference the symbol being renamed.

There was a conflict that could not be resolved.

These are the conflicts that cannot be resolved. E.g.: Declaration Conflict

Tracks the text spans that were modified as part of a rename operation

Information to track deltas of complexified spans Consider the following example where renaming a->b causes a conflict and Goo is an extension method: "a.Goo(a)" is rewritten to "NS1.NS2.Goo(NS3.a, NS3.a)" The OriginalSpan is the span of "a.Goo(a)" The NewSpan is the span of "NS1.NS2.Goo(NS3.a, NS3.a)" The ModifiedSubSpans are the pairs of complexified symbols sorted according to their order in the original source code span: "a", "NS3.a" "Goo", "NS1.NS2.Goo" "a", "NS3.a"

This annotation will be used by rename to mark all places where it needs to rename an identifier (token replacement) and where to check if the semantics have been changes (conflict detection).

This annotation should be put on tokens only.

This annotation will be used by rename to mark all places where it needs to rename an identifier (token replacement) and where to check if the semantics have been changes (conflict detection).

This annotation should be put on tokens only.

The span this token occupied in the original syntax tree. Can be used to show e.g. conflicts in the UI.

A flag indicating whether this is a location that needs to be renamed or just tracked for conflicts.

A flag indicating whether the token at this location has the same ValueText then the original name of the symbol that gets renamed.

When replacing the annotated token this string will be prepended to the token's value. This is used when renaming compiler generated fields and methods backing properties (e.g. "get_X" or "_X" for property "X").

When replacing the annotated token this string will be appended to the token's value. This is used when renaming compiler generated types whose names are derived from user given names (e.g. "XEventHandler" for event "X").

A single dimensional array of annotations to verify after rename.

States if this token is a Namespace Declaration Reference

States if this token is a member group reference, typically found in NameOf expressions

States if this token is annotated as a part of the Invocation Expression that needs to be checked for the Conflicts

This class is used to refer to a Symbol definition which could be in source or metadata it has a metadata name.

The metadata name for this symbol.

Count of symbol location (Partial Types, Constructors, etc).

A flag indicating that the associated symbol is an override of a symbol from metadata

A flag indicate if the rename operation is successful or not. If this is false, the would be with this resolution. All the other field or property would be or empty. If this is true, the would be null. All the other fields or properties would be valid.

The final solution snapshot. Including any renamed documents.

The list of all document ids of documents that have been touched for this rename operation.

Runs the entire rename operation OOP and returns the final result. More efficient (due to less back and forth marshaling) when the intermediary results of rename are not needed. To get the individual parts of rename remoted use and .

Equivalent to except that references to symbols are kept in a lightweight fashion to avoid expensive rehydration steps as a host and OOP communicate.

Find the locations that need to be renamed. Can cross process boundaries efficiently to do this.

Holds the Locations of a symbol that should be renamed, along with the symbol and Solution for the set. It is considered 'heavy weight' because it holds onto large entities (like Symbols) and thus should not be marshaled to/from a host to OOP.

A helper class that contains some of the methods and filters that must be used when processing the raw results from the FindReferences API.

Attempts to find all the locations to rename. Will not cross any process boundaries to do this.

Given a ISymbol, returns the renameable locations for a given symbol.

This method annotates the given syntax tree with all the locations that need to be checked for conflict after the rename operation. It also renames all the reference locations and expands any conflict locations.

The options describing this rename operation The root of the annotated tree.

Based on the kind of the symbol and the new name, this function determines possible conflicting names that should be tracked for semantic changes during rename.

The symbol that gets renamed. The new name for the symbol. List where possible conflicting names will be added to.

Identifies the conflicts caused by the new declaration created during rename.

The replacementText as given from the user. The new symbol (after rename). The original symbol that got renamed. All referenced symbols that are part of this rename session. The original solution when rename started. The resulting solution after rename. A mapping from new to old locations. The cancellation token. All locations where conflicts were caused because the new declaration.

Identifies the conflicts caused by implicitly referencing the renamed symbol.

The original symbol that got renamed. The new symbol (after rename). All implicit reference locations. The cancellation token. A list of implicit conflicts.

Identifies the conflicts caused by implicitly referencing the renamed symbol.

The new symbol (after rename). The SemanticModel of the document in the new solution containing the renamedSymbol The location of the renamedSymbol in the old solution The starting position of the renamedSymbol in the new solution The cancellation token. A list of implicit conflicts.

Identifies potential Conflicts into the inner scope locals. This may give false positives.

The Token that may introduce errors else where The symbols that this token binds to after the rename has been applied Returns if there is a potential conflict

Used to find if the replacement Identifier is valid

Gets the top most enclosing statement as target to call MakeExplicit on. It's either the enclosing statement, or if this statement is inside of a lambda expression, the enclosing statement of this lambda.

The token to get the complexification target for.

mentions that the result is for the base symbol of the rename

mentions that the result is for the overloaded symbols of the rename

Options for renaming a symbol.

If the symbol is a method rename its overloads as well. Rename identifiers in string literals that match the name of the symbol. Rename identifiers in comments that match the name of the symbol. If the symbol is a type renames the file containing the type declaration as well.

Options for renaming a symbol.

If the symbol is a method rename its overloads as well.

Rename identifiers in string literals that match the name of the symbol.

Rename identifiers in comments that match the name of the symbol.

If the symbol is a type renames the file containing the type declaration as well.

Options for renaming a document.

If the document contains a type declaration with matching name rename identifiers in strings that match the name as well. If the document contains a type declaration with matching name rename identifiers in comments that match the name as well.

Options for renaming a document.

If the document contains a type declaration with matching name rename identifiers in strings that match the name as well.

If the document contains a type declaration with matching name rename identifiers in comments that match the name as well.

Call to perform a rename of document or change in document folders. Returns additional code changes related to the document being modified, such as renaming symbols in the file. Each change is added as a in the returned . Each action may individually encounter errors that prevent it from behaving correctly. Those are reported in . Current supported actions that may be returned: Rename symbol action that will rename the type to match the document name. Sync namespace action that will sync the namespace(s) of the document to match the document folders.

The document to be modified The new name for the document. Pass null or the same name to keep unchanged. Options used to configure rename of a type contained in the document that matches the document's name. The new set of folders for the property

Individual action from RenameDocument APIs in . Represents changes that will be done to one or more document contents to help facilitate a smooth experience while moving documents around. See on use case and how to apply them to a solution.

Get any errors that have been noted for this action before it is applied. Can be used to present to a user.

Gets the description of the action. Can be used to present to a user to describe what extra actions will be taken.

Information about rename document calls that allows them to be applied as individual actions. Actions are individual units of work that can change the contents of one or more document in the solution. Even if the is empty, the document metadata will still be updated by calling To apply all actions use , or use a subset of the actions by calling . Actions can be applied in any order. Each action has a description of the changes that it will apply that can be presented to a user.

All applicable actions computed for the action. Action set may be empty, which represents updates to document contents rather than metadata. Document metadata will still not be updated unless is called.

Same as calling with as the argument

Applies each in order and returns the final solution. All actions must be contained in

An empty action set is still allowed and will return a modified solution that will update the document properties as appropriate. This means we can still support when is empty. It's desirable that consumers can call a rename API to produce a and immediately call without having to inspect the returned .

Attempts to find the document in the solution. Tries by documentId first, but that's not always reliable between analysis and application of the rename actions

Action that will rename a type to match the current document name. Works by finding a type matching the origanl name of the document (case insensitive) and updating that type.

Finds a matching type such that the display name of the type matches the name passed in, ignoring case. Case isn't used because documents with name "Foo.cs" and "foo.cs" should still have the same type name

Name of the document that the action was produced for.

The new document name that will be used.

The original name of the symbol that will be changed.

The new name for the symbol.

Action that will sync the namespace of the document to match the folders property of that document, similar to if a user performed the "Sync Namespace" code refactoring. For example, if a document is moved from "Bat/Bar/Baz" folder structure to "Bat/Bar/Baz/Bat" and contains a namespace definition of Bat.Bar.Baz in the document, then it would update that definition to Bat.Bar.Baz.Bat and update the solution to reflect these changes. Uses

Renaming a private symbol typically confines the set of references and potential conflicts to that symbols declaring project. However, rename may cascade to non-public symbols which may then require other projects be considered.

Given a symbol in a document, returns the "right" symbol that should be renamed in the case the name binds to things like aliases _and_ the underlying type at once.

Given a symbol, finds the symbol that actually defines the name that we're using.

Interface only for use by . Includes language specific implementations on how to get an appropriate speculated semantic model given an older semantic model and a changed method body.

Given a node, returns the parent method-body-esque node that we can get a new speculative semantic model for. Returns if not in such a location.

Given a previous semantic model, and a method-eque node in the current tree for that same document, attempts to create a new speculative semantic model using the top level symbols of but the new body level symbols produced for . Note: it is critical that no top level changes have occurred between the syntax tree that points at and the syntax tree that points at. In other words, they must be (..., topLevel: true). This function is undefined if they are not.

The original non-speculative semantic model we retrieved for this document at some point.

The current semantic model we retrieved for the . Could be speculative or non-speculative.

The current method body we retrieved the for.

The top level version of the project when we retrieved . As long as this is the same we can continue getting speculative models to use.

A mapping from a document id to the last semantic model we produced for it, along with the top level semantic version that that semantic model corresponds to. We can continue reusing the semantic model as long as no top level changes occur. In general this dictionary will only contain a single key-value pair. However, in the case of linked documents, there will be a key-value pair for each of the independent document links that a document has. A value simply means we haven't cached any information for that particular id.

a service that provides a semantic model that will re-use last known compilation if semantic version hasn't changed.

Don't call this directly. use (or an overload).

Attempts to return an speculative semantic model for if possible if is contained within a method body in the tree. Specifically, this will attempt to get an existing cached semantic model for . If it can find one, and the top-level semantic version for this project matches the cached version, and the position is within a method body, then it will be returned, just with the previous corresponding method body swapped out with the current method body. If this is not possible, the regular semantic model for will be returned. When using this API, semantic model should only be used to ask questions about nodes inside of the member that contains the given . As a speculative semantic model may be returned, location based information provided by it may be innacurate.

Attempts to return an speculative semantic model for if possible if is contained within a method body in the tree. Specifically, this will attempt to get an existing cached semantic model . If it can find one, and the top-level semantic version for this project matches the cached version, and the position is within a method body, then it will be returned, just with the previous corresponding method body swapped out with the current method body. If this is not possible, the regular semantic model for will be returned. When using this API, semantic model should only be used to ask questions about nodes inside of the member that contains the given . As a speculative semantic model may be returned, location based information provided by it may be innacurate.

Returns a new based off of the positions in , but which is guaranteed to fall entirely within the span of .

Returns the methodSymbol and any partial parts.

Returns true for void returning methods with two parameters, where the first parameter is of type and the second parameter inherits from or equals type.

Tells if an async method returns a task-like type, awaiting for which produces result

Gets the set of members in the inheritance chain of that are overridable. The members will be returned in furthest-base type to closest-base type order. i.e. the overridable members of will be at the start of the list, and the members of the direct parent type of will be at the end of the list. If a member has already been overridden (in or any base type) it will not be included in the list.

Searches the namespace for namespaces with the provided name.

Checks a given symbol for browsability based on its declaration location, attributes explicitly limiting browsability, and whether showing of advanced members is enabled. The optional editorBrowsableInfo parameters may be used to specify the symbols of the constructors of the various browsability limiting attributes because finding these repeatedly over a large list of symbols can be slow. If these are not provided, they will be found in the compilation.

First, remove symbols from the set if they are overridden by other symbols in the set. If a symbol is overridden only by symbols outside of the set, then it is not removed. This is useful for filtering out symbols that cannot be accessed in a given context due to the existence of overriding members. Second, remove remaining symbols that are unsupported (e.g. pointer types in VB) or not editor browsable based on the EditorBrowsable attribute.

Returns if the signature of this symbol requires the modifier. For example a method that takes List<int*[]> is unsafe, as is int* Goo { get; }. This will return for symbols that cannot have the modifier on them.

Returns true if symbol is a local variable and its declaring syntax node is after the current position, false otherwise (including for non-local symbols)

If the is a method symbol, returns if the method's return type is "awaitable", but not if it's . If the is a type symbol, returns if that type is "awaitable". An "awaitable" is any type that exposes a GetAwaiter method which returns a valid "awaiter". This GetAwaiter method may be an instance method or an extension method.

Returns true for symbols whose name starts with an underscore and are optionally followed by an integer or other underscores, such as '_', '_1', '_2', '__', '___', etc. These are treated as special discard symbol names.

Returns , if the symbol is marked with the .

if the symbol is marked with the .

Visits types or members that have signatures (i.e. methods, fields, etc.) and determines if any of them reference a pointer type and should thus have the modifier on them.

Checks if 'symbol' is accessible from within 'within'.

Checks if 'symbol' is accessible from within assembly 'within'.

Checks if 'symbol' is accessible from within name type 'within', with an optional qualifier of type "throughTypeOpt".

Checks if 'symbol' is accessible from within assembly 'within', with an qualifier of type "throughTypeOpt". Sets "failedThroughTypeCheck" to true if it failed the "through type" check.

Checks if 'symbol' is accessible from within 'within', which must be a INamedTypeSymbol or an IAssemblySymbol. If 'symbol' is accessed off of an expression then 'throughTypeOpt' is the type of that expression. This is needed to properly do protected access checks. Sets "failedThroughTypeCheck" to true if this protected check failed.

Returns the corresponding symbol in this type or a base type that implements interfaceMember (either implicitly or explicitly), or null if no such symbol exists (which might be either because this type doesn't implement the container of interfaceMember, or this type doesn't supply a member that successfully implements interfaceMember).

Like Span, except it has a start/end line instead of a start/end position.

Inclusive Exclusive

Like Span, except it has a start/end line instead of a start/end position.

Inclusive Exclusive

Inclusive

Exclusive

Gets extended host language services, which includes language services from .

Acquires a lease on a safe handle. The lease increments the reference count of the to ensure the handle is not released prior to the lease being released.

This method is intended to be used in the initializer of a using statement. Failing to release the lease will permanently prevent the underlying from being released by the garbage collector. The to lease. A , which must be disposed to release the resource. If the lease could not be acquired.

Represents a lease of a .

Releases the lease. The behavior of this method is unspecified if called more than once.

Gets semantic information, such as type, symbols, and diagnostics, about the parent of a token.

The SemanticModel object to get semantic information from. The token to get semantic information from. This must be part of the syntax tree associated with the binding. A cancellation token.

Fetches the ITypeSymbol that should be used if we were generating a parameter or local that would accept . If expression is a type, that's returned; otherwise this will see if it's something like a method group and then choose an appropriate delegate.

Note: there is a strong invariant that you only get arrays back from this that are exactly long. Putting arrays back into this of the wrong length will result in broken behavior. Do not expose this pool outside of this class.

Public so that the caller can assert that the new SourceText read all the way to the end of this successfully.

Returns the leading whitespace of the line located at the specified position in the given snapshot.

Same as OverlapsHiddenPosition but doesn't throw on cancellation. Instead, returns false in that case.

Generates a call to a method *through* an existing field or property symbol.

Generates an override of similar to the one generated for anonymous types.

In VB it's more idiomatic to write things like Dim t = TryCast(obj, SomeType) instead of Dim t As SomeType = TryCast(obj, SomeType), so we just elide the type from the decl. For C# we don't want to do this though. We want to always include the type and let the simplifier decide if it should be var or not.

Returns true if the binaryExpression consists of an expression that can never be negative, such as length or unsigned numeric types, being compared to zero with greater than, less than, or equals relational operator.

Gets a type by its metadata name to use for code analysis within a . This method attempts to find the "best" symbol to use for code analysis, which is the symbol matching the first of the following rules. If only one type with the given name is found within the compilation and its referenced assemblies, that type is returned regardless of accessibility. If the current defines the symbol, that symbol is returned. If exactly one referenced assembly defines the symbol in a manner that makes it visible to the current , that symbol is returned. Otherwise, this method returns .

The to consider for analysis. The fully-qualified metadata type name to find. The symbol to use for code analysis; otherwise, .

Gets implicit method, that wraps top-level statements.

Gets project-level effective severity of the given accounting for severity configurations from both the following sources: 1. Compilation options from ruleset file, if any, and command line options such as /nowarn, /warnaserror, etc. 2. Analyzer config documents at the project root directory or in ancestor directories.

Gets document-level effective severity of the given accounting for severity configurations from both the following sources: 1. Compilation options from ruleset file, if any, and command line options such as /nowarn, /warnaserror, etc. 2. Analyzer config documents at the document root directory or in ancestor directories.

Gets the effective diagnostic severity for the diagnostic ID corresponding to the given by looking up the severity settings in the options. If the provided options are specific to a particular tree, provide a non-null value for to look up tree specific severity options.

Tries to get configured severity for the given from bulk configuration analyzer config options, i.e. 'dotnet_analyzer_diagnostic.category-%RuleCategory%.severity = %severity%' or 'dotnet_analyzer_diagnostic.severity = %severity%' Docs: https://docs.microsoft.com/visualstudio/code-quality/use-roslyn-analyzers?view=vs-2019#set-rule-severity-of-multiple-analyzer-rules-at-once-in-an-editorconfig-file for details

Update a list in place, where a function has the ability to either transform or remove each item.

The type of items in the list. The type of state argument passed to the transformation callback. The list to update. A function which transforms each element. The function returns the transformed list element, or to remove the current item from the list. The state argument to pass to the transformation callback.

Attempts to remove the first item selected by .

True if any item has been removed.

Takes an array of s and produces a single resultant with all their values merged together. Absolutely no ordering guarantee is provided. It will be expected that the individual values from distinct enumerables will be interleaved together.

This helper is useful when doign parallel processing of work where each job returns an , but one final stream is desired as the result.

Runs after task completes in any fashion (success, cancellation, faulting) and ensures the channel writer is always completed. If the task faults then the exception from that task will be used to complete the channel

Returns true if is a given token is a child token of a certain type of parent node.

The type of the parent node. The node that we are testing. A function that, when given the parent node, returns the child token we are interested in.

Returns true if this node is found underneath the specified child in the given parent.

Creates a new tree of nodes from the existing tree with the specified old nodes replaced with a newly computed nodes.

The root of the tree that contains all the specified nodes. The nodes from the tree to be replaced. A function that computes a replacement node for the argument nodes. The first argument is one of the original specified nodes. The second argument is the same node possibly rewritten with replaced descendants.

Creates a new tree of tokens from the existing tree with the specified old tokens replaced with a newly computed tokens.

The root of the tree that contains all the specified tokens. The tokens from the tree to be replaced. A function that computes a replacement token for the argument tokens. The first argument is one of the originally specified tokens. The second argument is the same token possibly rewritten with replaced trivia.

Look inside a trivia list for a skipped token that contains the given position.

If the position is inside of token, return that token; otherwise, return the token to the right.

If the position is inside of token, return that token; otherwise, return the token to the left.

Creates a new token with the leading trivia removed.

Creates a new token with the trailing trivia removed.

Finds the node within the given corresponding to the given . If the is , then returns the given node.

Gets a list of ancestor nodes (including this node)

Returns the identifier, keyword, contextual keyword or preprocessor keyword touching this position, or a token of Kind = None if the caret is not touching either.

If the position is inside of token, return that token; otherwise, return the token to the right.

If the position is inside of token, return that token; otherwise, return the token to the left.

Finds the node in the given corresponding to the given . If the is , then returns the root node of the tree.

Returns the first non-whitespace position on the given line, or null if the line is empty or contains only whitespace.

Returns the first non-whitespace position on the given line as an offset from the start of the line, or null if the line is empty or contains only whitespace.

Determines whether the specified line is empty or contains whitespace only.

merge provided spans to each distinct group of spans in ascending order

Returns true if the span encompasses the specified node or token and is contained within its trivia.

Returns true if the span encompasses a span between the specified nodes or tokens and is contained within trivia around them.

Lazily returns all nested types contained (recursively) within this namespace or type. In case of a type, it is included itself as the first result.

Standard format for displaying to the user.

No return type.

Contains enough information to determine whether two symbols have the same signature.

The token to the left of . This token may be touching the position.

The first token to the left of that we're not touching. Equal to if we aren't touching .

Is in the base list of a type declaration. Note, this only counts when at the top level of the base list, not *within* any type already in the base list. For example class C : $$ is in the base list. But class C : A<$$> is not.

Performs several edits to a document. If multiple edits are made within the same expression context, then the document/semantic-model will be forked after each edit so that further edits can see if they're still safe to apply.

Performs several edits to a document. If multiple edits are made within a method body then the document/semantic-model will be forked after each edit so that further edits can see if they're still safe to apply.

Helper function for fix-all fixes where individual fixes may affect the viability of another. For example, consider the following code: if ((double)x == (double)y) In this code either cast can be removed, but at least one cast must remain. Even though an analyzer marks both, a fixer must not remove both. One way to accomplish this would be to have the fixer do a semantic check after each application. However This is extremely expensive, especially for hte common cases where one fix does not affect each other. To address that, this helper groups fixes at certain boundary points. i.e. at statement boundaries. If there is only one fix within the boundary, it does not do any semantic verification. However, if there are multiple fixes in a boundary it will call into to validate if the subsequent fix can be made or not.

Creates a new instance of this text document updated to have the text specified.

Creates a new instance of this additional document updated to have the text specified.

Creates a new instance of this analyzer config document updated to have the text specified.

Stores the source information for an value. Helpful when tracking down tokens which aren't properly disposed.

use in product code to get and use in test to get waiter.

indicate whether asynchronous listener is enabled or not. it is tri-state since we want to retrieve this value, if never explicitly set, from environment variable and then cache it. we read value from environment variable (RoslynWaiterEnabled) because we want team, that doesn't have access to Roslyn code (InternalVisibleTo), can use this listener/waiter framework as well. those team can enable this without using API

indicate whether is enabled or not it is tri-state since we want to retrieve this value, if never explicitly set, from environment variable and then cache it. we read value from environment variable (RoslynWaiterDiagnosticTokenEnabled) because we want team, that doesn't have access to Roslyn code (InternalVisibleTo), can use this listener/waiter framework as well. those team can enable this without using API

Provides a default value for .

Enable or disable TrackActiveTokens for test

Get Waiters for listeners for test

Wait for all of the instances to finish their work.

This is a very handy method for debugging hangs in the unit test. Set a break point in the loop, dig into the waiters and see all of the active values representing the remaining work.

Get all saved DiagnosticAsyncToken to investigate tests failure easier

Returns a task which completes when all asynchronous operations currently tracked by this waiter are completed. Asynchronous operations are expedited when possible, meaning artificial delays placed before asynchronous operations are shortened.

Creates a task that will complete after a time delay, but can be expedited if an operation is waiting for the task to complete.

The time to wait before completing the returned task, or TimeSpan.FromMilliseconds(-1) to wait indefinitely. A cancellation token to observe while waiting for the task to complete. if the delay compeleted normally; otherwise, if the delay completed due to a request to expedite the delay. represents a negative time interval other than TimeSpan.FromMilliseconds(-1). -or- The argument's property is greater than . The delay has been canceled.

Return for the given featureName We have this abstraction so that we can have isolated listener/waiter in unit tests

Get for given feature. same provider will return a singleton listener for same feature

Modification of the murmurhash2 algorithm. Code is simpler because it operates over strings instead of byte arrays. Because each string character is two bytes, it is known that the input will be an even number of bytes (though not necessarily a multiple of 4). This is needed over the normal 'string.GetHashCode()' because we need to be able to generate 'k' different well distributed hashes for any given string s. Also, we want to be able to generate these hashes without allocating any memory. My ideal solution would be to use an MD5 hash. However, there appears to be no way to do MD5 in .NET where you can: a) feed it individual values instead of a byte[] b) have the hash computed into a byte[] you provide instead of a newly allocated one Generating 'k' pieces of garbage on each insert and lookup seems very wasteful. So, instead, we use murmur hash since it provides well distributed values, allows for a seed, and allocates no memory. Murmur hash is public domain. Actual code is included below as reference.

Provides mechanism to efficiently obtain bloom filter hash for a value. Backed by a single element cache.

Although calculating this hash isn't terribly expensive, it does involve multiple (usually around 13) hashings of the string (the actual count is ). The typical usage pattern of bloom filters is that some operation (eg: find references) requires asking a multitude of bloom filters whether a particular value is likely contained. The vast majority of those bloom filters will end up hashing that string to the same values, so we put those values into a simple cache and see if it can be used before calculating. Local testing has put the hit rate of this at around 99%. Note that it's possible for this method to return an array from the cache longer than hashFunctionCount, but if so, it's guaranteed that the values returned in the first hashFunctionCount entries are the same as if the cache hadn't been used.

A documentation comment derived from either source text or metadata.

True if an error occurred when parsing.

The full XML text of this tag.

The text in the <example> tag. Null if no tag existed.

The text in the <summary> tag. Null if no tag existed.

The text in the <returns> tag. Null if no tag existed.

The text in the <value> tag. Null if no tag existed.

The text in the <remarks> tag. Null if no tag existed.

The names of items in <param> tags.

The names of items in <typeparam> tags.

The types of items in <exception> tags.

The item named in the <completionlist> tag's cref attribute. Null if the tag or cref attribute didn't exist.

Used for method, to prevent new allocation of string

Cache of the most recently parsed fragment and the resulting DocumentationComment

Parses and constructs a from the given fragment of XML.

The fragment of XML to parse. A DocumentationComment instance.

Helper class for parsing XML doc comments. Encapsulates the state required during parsing.

Parse and construct a from the given fragment of XML.

The fragment of XML to parse. A DocumentationComment instance.

Returns the text for a given parameter, or null if no documentation was given for the parameter.

Returns the text for a given type parameter, or null if no documentation was given for the type parameter.

Returns the texts for a given exception, or an empty if no documentation was given for the exception.

An empty comment.

Finds the constructor which takes exactly one argument, which must be of type EditorBrowsableState. It does not require that the EditorBrowsableAttribute and EditorBrowsableState types be those shipped by Microsoft, but it does demand the types found follow the expected pattern. If at any point that pattern appears to be violated, return null to indicate that an appropriate constructor could not be found.

The TypeLib*Attribute classes that accept TypeLib*Flags with FHidden as an option all have two constructors, one accepting a TypeLib*Flags and the other a short. This methods gets those two constructor symbols for any of these attribute classes. It does not require that the either of these types be those shipped by Microsoft, but it does demand the types found follow the expected pattern. If at any point that pattern appears to be violated, return an empty enumerable to indicate that no appropriate constructors were found.

Helper for checking whether cycles exist in the extension ordering. Throws if a cycle is detected.

A cycle was detected in the extension ordering.

Returns an that will call on when it is disposed.

An optional interface which allows an environment to customize the behavior for synchronous methods that need to block on the result of an asynchronous invocation. An implementation of this is provided in the MEF catalog when applicable.

For Visual Studio, Microsoft.VisualStudio.Threading provides the JoinableTaskFactory.Run method, which is the expected way to invoke an asynchronous method from a synchronous entry point and block on its completion. Other environments may choose to use this or any other strategy, or omit an implementation of this interface to allow callers to simply use . New code is expected to use fully-asynchronous programming where possible. In cases where external APIs restrict ability to be asynchronous, this service allows Roslyn to adhere to environmental policies related to joining asynchronous work.

Utility class that can be used to track the progress of an operation in a threadsafe manner.

An XML parser that is designed to parse small fragments of XML such as those that appear in documentation comments. PERF: We try to re-use the same underlying to reduce the allocation costs of multiple parses.

Parse the given XML fragment. The given callback is executed until either the end of the fragment is reached or an exception occurs.

Type of an additional argument passed to the delegate. The fragment to parse. Action to execute while there is still more to read. Additional argument passed to the callback. It is important that the action advances the , otherwise parsing will never complete.

A text reader over a synthesized XML stream consisting of a single root element followed by a potentially infinite stream of fragments. Each time "SetText" is called the stream is rewound to the element immediately following the synthetic root node.

Current text to validate.

Determines, using heuristics, what the next likely value is in this enum.

Helper class to analyze the semantic effects of a speculated syntax node replacement on the parenting nodes. Given an expression node from a syntax tree and a new expression from a different syntax tree, it replaces the expression with the new expression to create a speculated syntax tree. It uses the original tree's semantic model to create a speculative semantic model and verifies that the syntax replacement doesn't break the semantics of any parenting nodes of the original expression.

Creates a semantic analyzer for speculative syntax replacement.

Original expression to be replaced. New expression to replace the original expression. Semantic model of node's syntax tree. Cancellation token. True if semantic analysis should be skipped for the replaced node and performed starting from parent of the original and replaced nodes. This could be the case when custom verifications are required to be done by the caller or semantics of the replaced expression are different from the original expression. True if semantic analysis should fail when any of the invocation expression ancestors of in original code has overload resolution failures.

Original expression to be replaced.

First ancestor of which is either a statement, attribute, constructor initializer, field initializer, default parameter initializer or type syntax node. It serves as the root node for all semantic analysis for this syntax replacement.

Semantic model for the syntax tree corresponding to

Node which replaces the . Note that this node is a cloned version of node, which has been re-parented under the node to be speculated, i.e. .

Node created by replacing under node. This node is used as the argument to the GetSpeculativeSemanticModel API and serves as the root node for all semantic analysis of the speculated tree.

Speculative semantic model used for analyzing the semantics of the new tree.

Determines whether performing the given syntax replacement will change the semantics of any parenting expressions by performing a bottom up walk from the up to in the original tree and simultaneously walking bottom up from up to in the speculated syntax tree and performing appropriate semantic comparisons.

Checks whether the semantic symbols for the and are non-null and compatible.

Determine if removing the cast could cause the semantics of System.Object method call to change. E.g. Dim b = CStr(1).GetType() is necessary, but the GetType method symbol info resolves to the same with or without the cast.

Determines if the symbol is a non-overridable, non static method on System.Object (e.g. GetType)

Returns if items were already cached for this and , otherwise. Callers should use this value to determine if they should call or not. A result of does *not* mean that is non-.

If the token1 is expected to be part of the leading trivia of the token2 then the trivia before the token1FullSpanEnd, which the fullspan end of the token1 should be ignored

this will create a span that includes its trailing trivia of its previous token and leading trivia of its next token for example, for code such as "class A { int ...", if given tokens are "A" and "{", this will return span [] of "class[ A { ]int ..." which included trailing trivia of "class" which is previous token of "A", and leading trivia of "int" which is next token of "{"

Content hash of the original document the containing the invocation to be intercepted. (See ) The position in the file of the invocation that was intercepted. This is the absolute start of the name token being invoked (e.g. this.$$Goo(x, y, z)) (see ). Content hash of the original document the containing the invocation to be intercepted. (See ) The position in the file of the invocation that was intercepted. This is the absolute start of the name token being invoked (e.g. this.$$Goo(x, y, z)) (see ).

Content hash of the original document the containing the invocation to be intercepted. (See )

The position in the file of the invocation that was intercepted. This is the absolute start of the name token being invoked (e.g. this.$$Goo(x, y, z)) (see ).

The original expression that is being replaced by . This will be in the that points at.

The new node that n was replaced with. This will be in the that points at.

The original semantic model that was contained in.

A forked semantic model off of . In that model will have been replaced with .

Given a set of folders from build the namespace that would match the folder structure. If a document is located in { "Bat" , "Bar", "Baz" } then the namespace could be "Bat.Bar.Baz". If a rootNamespace is provided, it is prepended to the generated namespace. Returns null if the folders contain parts that are invalid identifiers for a namespace.

Used when the consumeItems routine will only pull items on a single thread (never concurrently). produceItems can be called concurrently on many threads.

Used when the consumeItems routine will only pull items on a single thread (never concurrently). produceItems can be called on a single thread as well (never concurrently).

Version of when caller the prefers the results being pre-packaged into arrays to process.

Version of when the caller prefers working with a stream of results.

IEnumerable<TSource> -> Task. Callback receives IAsyncEnumerable items.

IAsyncEnumerable<TSource> -> Task. Callback receives IAsyncEnumerable items.

IEnumerable<TSource> -> Task. Callback receives ImmutableArray of items.

IAsyncEnumerable<TSource> -> Task. Callback receives ImmutableArray of items.

IEnumerable<TSource> -> Task<TResult> Callback receives an IAsyncEnumerable of items.

IAsyncEnumerable<TSource> -> Task<TResult>. Callback receives an IAsyncEnumerable of items.

IEnumerable<TSource> -> Task<ImmutableArray<TResult>>

IAsyncEnumerable<TSource> -> Task<ImmutableArray<TResult>>

Helper utility for the pattern of a pair of a production routine and consumption routine using a channel to coordinate data transfer. The provided are used to create a , which will then then manage the rules and behaviors around the routines. Importantly, the channel handles backpressure, ensuring that if the consumption routine cannot keep up, that the production routine will be throttled. is the routine called to actually produce the items. It will be passed an action that can be used to write items to the channel. Note: the channel itself will have rules depending on if that writing can happen concurrently multiple write threads or just a single writer. See for control of this when creating the channel. is the routine called to consume the items. Similarly, reading can have just a single reader or multiple readers, depending on the value passed into .

Helper as VB's CType doesn't work without arithmetic overflow.

Helper class to allow one to do simple regular expressions over a sequence of objects (as opposed to a sequence of characters).

Matcher equivalent to (m*)

Matcher equivalent to (m+)

Matcher equivalent to (m_1|m_2|...|m_n)

Matcher equivalent to (m_1 ... m_n)

Matcher that matches an element if the provide predicate returns true.