Microsoft.CodeAnalysis.Workspaces

A factory for based on a path.

Maps a path to .

Path. Metadata reference properties. A corresponding to the and parameters.

APIs for constructing documentation comment id's, and finding symbols that match ids.

Creates an id string used by external documenation comment files to identify declarations of types, namespaces, methods, properties, etc.

Creates an id string used to reference type symbols (not strictly declarations, includes arrays, pointers, type parameters, etc.)

Gets all declaration symbols that match the declaration id string

Try get all declaration symbols that match the declaration id string

Gets the first declaration symbol that matches the declaration id string, order undefined.

Gets the symbols that match the reference id string.

Gets the first symbol that matches the reference id string, order undefined.

Use in an exception filter to report a fatal error. Unless the exception is it calls . The exception is passed thru (the method returns false).

False to avoid catching the exception.

Use in an exception filter to report a fatal error. Unless the exception is it calls . The exception is passed thru (the method returns false).

False to avoid catching the exception.

Use in an exception filter to report a fatal error. Calls and passes the exception thru (the method returns false).

False to avoid catching the exception.

Checks for the given ; if the is true, immediately terminates the process without running any pending finally blocks or finalizers and causes a crash dump to be collected (if the system is configured to do so). Otherwise, the process continues normally.

The conditional expression to evaluate. An optional message to be recorded in the dump in case of failure. Can be null.

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

The syntax node types this classifier is able to classify

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 SyntaxNodeTypes property. Implementations should return null (instead of an empty enumerable) if they have no classifications for the provided node.

This method will be called for all nodes that match the types specified by the SyntaxTokenKinds property. Implementations should return null (instead of an empty enumerable) if they have no classifications for the provided token.

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.

An action produced by a or a .

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

An optional Id for the code action. If non-null, then this Id must be unique amongst all the code actions produced by the corresponding or .

The sequence of operations that define the code action.

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

The sequence of operations used to construct a preview.

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.

Computes changes for a single document. Override this method if you want to implement a subclass that changes a single document.

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

Creates a code action for a change to a single document. Use this factory when the change is trivial to compute or is already computed.

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

Creates a code action for a change to more than one document within a solution. Use this factory when the change is trivial to compute or is already computed.

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.

A that can vary with user specified options.

Gets the options to use with this code action. This method is gauranteed 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.

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

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.

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 gauranteed to be called on the UI thread.

A for applying solution changes to a workspace.

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

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

Helper class that implements using delegates passed to its constructor.

Context for code fixes provided by an .

Document corresponding to the to fix.

Text span within the to fix.

Diagnostics to fix.

CancellationToken.

Creates a code fix context to be passed into method.

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 .

Helper class for "Fix all occurrences" code fix providers for Simplification code fix providers that just add simplifier/formatter annotations as part of code fixes. This provider batches all the simplifier annotation actions within a document into a single code action, instead of creating separate code actions for each added annotation.

Get node on which to add simplifier and formatter annotation for fixing the given diagnostic.

Fix all occurrences logging.

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.

Default batch fix all provider for simplification fixers which only add Simplifier annotations to documents. This provider batches all the simplifier annotation actions within a document into a single code action, instead of creating separate code actions for each added annotation. This fixer supports fixes for the following fix all scopes: , and .

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

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

Solution to fix all occurences.

Project within which fix all occurences was triggered.

Document within which fix all occurences was triggered.

Underlying which triggered this fix all.

FixAllScope to fix all occurrences.

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

CodeAction Id to generate a fix all occurrences code fix.

CancellationToken for fix all session.

Gets all the diagnostics in the given document filtered by .

Gets all the diagnostics in the given project filtered by .

Gets a new with the given cancellationToken.

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

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.

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

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 provider fixes for.

Computes one or more fixes for the specified .

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.

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 .

Options for controlling the code produced by the .

A location used to determine the best place to generate a member. This is only used for determining which part of a partial type to generate in. If a type only has one part, or an API is used that specifies the type, then this is not used. A part is preferred if it surrounds this context location. If no part surrounds this location then a part is preferred if it comes from the same SyntaxTree as this location. If there is no such part, then any part may be used for generation. This option is not necessary if or are provided.

A hint to the code generation service to specify where the generated code should be placed. Code will be generated after this location if the location is valid in the type or symbol being generated into, and it is possible to generate the code after it. If this option is provided, neither nor are needed.

A hint to the code generation service to specify where the generated code should be placed. Code will be generated before this location if the location is valid in the type or symbol being generated into, and it is possible to generate the code after it. If this option is provided, neither nor are needed.

True if the code generation service should try to automatically add imports to the file for any generated code. Defaults to true. Not used when generating directly into a declaration.

True if, when adding a System import, the import should be placed above non-System imports. Defaults to true. Only used if is true.

Contains additional imports to be automatically added. This is useful for adding imports that are part of a list of statements.

True if members of a symbol should also be generated along with the declaration. If false, only the symbol's declaration will be generated.

True if the code generator should merge namespaces which only contain other namespaces into a single declaration with a dotted name. False if the nesting should be preserved and each namespace declaration should be nested and should only have a single non-dotted name. Merging can only occur if the namespace only contains a single member that is also a namespace.

True if the code generation should put multiple attributes in a single attribute declaration, or if should have a separate attribute declaration for each attribute. For example, in C# setting this to True this would produce "[Foo, Bar]" while setting it to False would produce "[Foo][Bar]"

True if the code generator should always generate accessibility modifiers, even if they are the same as the defaults for that symbol. For example, a private field in C# does not need its accessibility specified as it will be private by default. However, if this option is set to true 'private' will still be generated.

True if the code generator should generate empty bodies for methods along with the method declaration. If false, only method declarations will be generated.

True if the code generator should generate documentation comments where available

True if the code generator should automatically attempt to choose the appropriate location to insert members. If false and a generation location is not specified by AfterThisLocation, or BeforeThisLocation, members will be inserted at the end of the destination definition.

True if the code generator should attempt to reuse the syntax of the constituent entities, such as members, access modifier tokens, etc. while attempting to generate code. If any of the member symbols have zero declaring syntax references (non-source symbols) OR two or more declaring syntax references (partial definitions), then syntax is not reused. If false, then the code generator will always synthesize a new syntax node and ignore the declaring syntax references.

Generates symbols that describe declarations to be generated.

Determines if the symbol is purely a code generation symbol.

Creates an event symbol that can be used to describe an event declaration.

Creates a property symbol that can be used to describe a property declaration.

Creates a field symbol that can be used to describe a field declaration.

Creates a constructor symbol that can be used to describe a constructor declaration.

Creates a destructor symbol that can be used to describe a destructor declaration.

Creates a method symbol that can be used to describe a method declaration.

Creates a method symbol that can be used to describe an operator declaration.

Creates a method symbol that can be used to describe a conversion declaration.

Creates a parameter symbol that can be used to describe a parameter declaration.

Creates a type parameter symbol that can be used to describe a type parameter declaration.

Creates a pointer type symbol that can be used to describe a pointer type reference.

Creates an array type symbol that can be used to describe an array type reference.

Creates an method type symbol that can be used to describe an accessor method declaration.

Create attribute data that can be used in describing an attribute declaration.

Creates a named type symbol that can be used to describe a named type declaration.

Creates a method type symbol that can be used to describe a delegate type declaration.

Creates a namespace symbol that can be used to describe a namespace declaration.

A generator used for creating or modifing member declarations in source.

Returns a newly created event declaration node from the provided event.

Returns a newly created field declaration node from the provided field.

Returns a newly created method declaration node from the provided method.

Returns a newly created property declaration node from the provided property.

Returns a newly created named type declaration node from the provided named type.

Returns a newly created namespace declaration node from the provided namespace.

Create a new declaration node with an event declaration of the same signature as the specified symbol added to it.

Create a new declaration node with a field declaration of the same signature as the specified symbol added to it.

Create a new declaration node with a method declaration of the same signature as the specified symbol added to it.

Create a new declaration node with a property declaration of the same signature as the specified symbol added to it.

Create a new declaration node with a named type declaration of the same signature as the specified symbol added to it.

Create a new declaration node with multiple member declarations of the same signatures as the specified symbols added to it.

Create a new declaration node with one or more parameter declarations of the same signature as the specified symbols added to it.

Create a new declaration node with the specified attributes added to it.

Removes the specified attribute node from the given declaration node.

Create a new declaration node with one or more statements added to its body.

Create a new solution where the declaration of the destination symbol has an additional event of the same signature as the specified event symbol. Returns the document in the new solution where the destination symbol is declared.

Create a new solution where the declaration of the destination symbol has an additional field of the same signature as the specified field symbol. Returns the document in the new solution where the destination symbol is declared.

Create a new solution where the declaration of the destination symbol has an additional method of the same signature as the specified method symbol. Returns the document in the new solution where the destination symbol is declared.

Create a new solution where the declaration of the destination symbol has an additional property of the same signature as the specified property symbol. Returns the document in the new solution where the destination symbol is declared.

Create a new solution where the declaration of the destination symbol has an additional named type of the same signature as the specified named type symbol. Returns the document in the new solution where the destination symbol is declared.

Create a new solution where the declaration of the destination symbol has an additional namespace of the same signature as the specified namespace symbol. Returns the document in the new solution where the destination symbol is declared.

Create a new solution where the declaration of the destination symbol has an additional namespace or type of the same signature as the specified namespace or type symbol. Returns the document in the new solution where the destination symbol is declared.

Create a new solution where the declaration of the destination symbol has additional members of the same signature as the specified member symbols. Returns the document in the new solution where the destination symbol is declared.

Returns true if additional declarations can be added to the destination symbol's declaration.

Returns a newly created event declaration node from the provided event.

Returns a newly created field declaration node from the provided field.

Returns a newly created method declaration node from the provided method.

Returns a newly created property declaration node from the provided property.

Returns a newly created named type declaration node from the provided named type.

Returns a newly created namespace declaration node from the provided namespace.

Adds an event into destination.

Adds a field into destination.

Adds a method into destination.

Adds a property into destination.

Adds a named type into destination.

Adds a namespace into destination.

Adds a method into destination.

Adds the parameters to destination.

Adds the attributes to destination.

Remove the given attribute from destination.

Update the modifiers list for the given declaration node.

Update the accessibility modifiers for the given declaration node, retaining the trivia of the existing modifiers.

Update the type for the given declaration node.

Replace the existing members with the given newMembers for the given declaration node.

Adds the statements to destination.

Adds a field with the provided signature into destination.

Adds a method with the provided signature into destination.

Adds a property with the provided signature into destination.

Adds a named type into destination.

Adds a namespace into destination.

Adds a namespace or type into destination.

Adds all the provided members into destination.

true if destination is a location where other symbols can be added to.

When we are generating literals, we sometimes want to emit code vs. the numeric literal. This class gives the constants for all ones we want to convert

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.

Gets the for the specified language.

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 parameter declaration.

Creates a parameter declaration matching an existing parameter symbol.

Creates a property declaration.

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 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 member

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.

Creates a compilation unit declaration

Creates a namespace import declaration.

Creates an attribute.

Creates an attribute matching existing attribute data.

Creates an attribute argument.

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

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

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 throw and exception.

An optional expression that can be thrown.

Creates a statement that declares a single local variable.

Creates a if-then-else statement or equivalent

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

Creates a if-then-else statement or equivalent

The if-condition. The statements that are executed if the condition is true. A single statement that is executed if the condition is false. Typically this anther if-then-else statement.

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

Creates a switch statement that branches to a section 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 try-catch or try-catch-finally statement.

Creates a try-finally statement.

Creates a catch-clause.

Creates a while-loop statement

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 methods this-parameter.

Creates an expression that denotes the containing methods base-parameter.

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

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.

Creates a name expression from a dotted name string.

Creates an expression that denotes a 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 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 aexpression that denotes a coalesce operation.

Creates a member access expression.

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 denotes an is-type-check operation.

Creates an expression that denotes an as-type operation.

Creates an expression that denotes a runtime cast operation.

Creates an expression that denotes a numerical 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 a lambda parameter.

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#)

Context for code refactorings provided by an .

Document corresponding to the to refactor.

Text span within the 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.

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 .

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

The name of the .

The source language this provider can provide refactorings for. See .

a logger that aggregate multiple loggers

LogMessage that creates key value map lazily

helper class to aggregate some numeric value log in client side

maximum value

minimum value

middle value of the total data set

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

provide a way to log activities to various back end such as etl, code marker and etc

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

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.

log message that can generate string lazily

Logger will call this to return LogMessage to its pool

no op log block

a logger that doesn't do anything

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

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.

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).

Returns true if is a given token is a child token of 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.

create a new root node from the given root after adding annotations to the tokens tokens should belong to the given root

create a new root node from the given root after adding annotations to the nodes nodes should belong to the given root

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.

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.

Returns true if the provided position is in a hidden region inaccessible to the user.

this will return either regular semantic model or speculative semantic based on context. any feature that is involved in typing or run on UI thread should use this to take advantage of speculative semantic model whenever possible automatically. when using this API, semantic model should only be used to ask node inside of the given span. otherwise, it might throw if semantic model returned by this API is a speculative semantic model. also, symbols from the semantic model returned by this API might have out of date location information. if exact location (not relative location) is needed from symbol, regular GetSemanticModel should be used.

this will return either regular semantic model or speculative semantic based on context. any feature that is involved in typing or run on UI thread should use this to take advantage of speculative semantic model whenever possible automatically. when using this API, semantic model should only be used to ask node inside of the given node except ones that belong to member signature. otherwise, it might throw if semantic model returned by this API is a speculative semantic model. also, symbols from the semantic model returned by this API might have out of date location information. if exact location (not relative location) is needed from symbol, regular GetSemanticModel should be used.

Searches the namespace for namespaces with the provided name.

Returns true if this symbol contains anything unsafe within it. for example List<int*[]> is unsafe, as it "int* Foo { get; }"

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)

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 attribute constructor 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 providing these constructor symbols, they should be in the format provided by EditorBrowsableHelpers.GetSpecial*AttributeConstructor(). If these are not provided, they will be found in the compilation.

If the is a method symbol, returns True if the method's return type is "awaitable". If the is a type symbol, returns True 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.

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.

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. NOTE(cyrusn): I expect this function to be called a lot. As such, I do not do any memory allocations in the function itself (including not making any iterators). This does mean that certain helper functions that we'd like to call are inlined in this method to prevent the overhead of returning collections or enumerators.

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.

check whether the given span is intersects with the tree

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.

Standard format for displaying to the user.

No return type.

Contains enough information to determine whether two symbols have the same signature.

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

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.

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.

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 "{"

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 <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 named in the %lt;completionlist> tag's cref attribute. Null if the tag or cref attribute didn't exist.

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.

Determines, using heuristics, what the next likely value is in this enum.

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.

Look inside a trivia list for a skipped token that contains the given position.

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)

Matcher equivalent to (m_1 ... m_n)

Matcher that matches an element if the provide predicate returns true.

Ensures that any 'names' is unique and does not collide with any other name. Names that are marked as IsFixed can not be touched. This does mean that if there are two names that are the same, and both are fixed that you will end up with non-unique names at the end.

Transforms baseName into a name that does not conflict with any name in 'reservedNames'

Utility class that can be used to track the progress of an operation in a threadsafe manner.

Breaks an identifier string into constituent parts.

Provides a way to test two symbols for equivalence. While there are ways to ask for different sorts of equivalence, the following must hold for two symbols to be considered equivalent. 1) The kinds of the two symbols must match. 2) The names of the two symbols must match. 3) The arity of the two symbols must match. 4) If the symbols are methods or parameterized properties, then the signatures of the two symbols must match. 5) Both symbols must be definitions or must be instantiations. If they are instantiations, then they must be instantiated in the same manner. 6) The containing symbols of the two symbols must be equivalent. Note: equivalence does not concern itself with whole symbols. Two types are considered equivalent if the above hold, even if one type has different members than the other. Note: type parameters, and signature parameters are not considered 'children' when comparing symbols. Options are provided to tweak the above slightly. For example, by default, symbols are equivalent only if they come from the same assembly. However, one can ask if two symbols are equivalent even if their assemblies differ.

Compares given symbols and for equivalence.

Compares given symbols and for equivalence and populates with equivalent non-nested named type key-value pairs that are contained in different assemblies. These equivalent named type key-value pairs represent possibly equivalent forwarded types, but this API doesn't perform any type forwarding equivalence checks.

This API is only supported for .

Worker for comparing two named types for equivalence. Note: The two types must have the same TypeKind.

The first type to compare The second type to compare Map of equivalent non-nested types to be populated, such that each key-value pair of named types are equivalent but reside in different assemblies. This map is populated only if we are ignoring assemblies for symbol equivalence comparison, i.e. is true. True if the two types are equivalent.

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 upto 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.

An interval tree represents an ordered tree data structure to store intervals of the form [start, end). It allows you to efficiently find all intervals that intersect or overlap a provided interval.

Initializes a new instance of that is empty.

Initializes a new instance of that contains the specified span.

TextSpan contained by the span set.

Initializes a new instance of that contains the specified list of spans.

The spans to be added. The list of spans will be sorted and normalized (overlapping and adjoining spans will be combined). This constructor runs in O(N log N) time, where N = spans.Count. is null.

Finds the union of two span sets.

The first span set. The second span set. The new span set that corresponds to the union of and . This operator runs in O(N+M) time where N = left.Count, M = right.Count. Either or is null.

Finds the overlap of two span sets.

The first span set. The second span set. The new span set that corresponds to the overlap of and . This operator runs in O(N+M) time where N = left.Count, M = right.Count. or is null.

Finds the intersection of two span sets.

The first span set. The second span set. The new span set that corresponds to the intersection of and . This operator runs in O(N+M) time where N = left.Count, M = right.Count. is null. is null.

Finds the difference between two sets. The difference is defined as everything in the first span set that is not in the second span set.

The first span set. The second span set. The new span set that corresponds to the difference between and . Empty spans in the second set do not affect the first set at all. This method returns empty spans in the first set that are not contained by any set in the second set. is null. is null.

Determines whether two span sets are the same.

The first set. The second set. true if the two sets are equivalent, otherwise false.

Determines whether two span sets are not the same.

The first set. The second set. true if the two sets are not equivalent, otherwise false.

Determines whether this span set overlaps with another span set.

The span set to test. true if the span sets overlap, otherwise false. is null.

Determines whether this span set overlaps with another span.

The span to test. true if this span set overlaps with the given span, otherwise false.

Determines whether this span set intersects with another span set.

Set to test. true if the span sets intersect, otherwise false. is null.

Determines whether this span set intersects with another span.

true if this span set intersects with the given span, otherwise false.

Gets a unique hash code for the span set.

A 32-bit hash code associated with the set.

Determines whether this span set is the same as another object.

The object to test. true if the two objects are equal, otherwise false.

Provides a string representation of the set.

The string representation of the set.

Private ctor for use when the span list is already normalized.

An already normalized span list.

This annotation will be used by the expansion/reduction to annotate expanded syntax nodes to store the information that an alias was used before expansion.

This Object contains the options that needs to be drilled down to the Simplification Engine

This option tells the simplification engine if the Qualified Name should be replaced by Alias if the user had initially not used the Alias

This option influences the name reduction of members of a module in VB. If set to true, the name reducer will e.g. reduce Namespace.Module.Member to Namespace.Member.

This option says that if we should simplify the Generic Name which has the type argument inferred

This option says if we should simplify the Explicit Type in Local Declarations

This option says if we should simplify to NonGeneric Name rather than GenericName

This option says if we should simplify from Derived types to Base types in Static Member Accesses

This option says if we should simplify away the this. or Me. in member access expression

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

Expands and Reduces subtrees. Expansion: 1) Replaces names with fully qualified dotted names. 2) Adds parentheses around expressions 3) Adds explicit casts/conversions where implicit conversions exist 4) Adds escaping to identifiers 5) Rewrites extension method invocations with explicit calls on the class containing the extension method. Reduction: 1) Shortens dotted names to their minimally qualified form 2) Removes unnecessary parentheses 3) Removes unnecessary casts/conversions 4) Removes unnecessary escaping 5) Rewrites explicit calls to extension methods to use dot notation

The annotation the reducer uses to identify sub trees to be reduced. The Expand operations add this annotation to nodes so that the Reduce operations later find them.

This is the annotation used by the simplifier and expander to identify Predefined type and preserving them from over simplification

Expand qualifying parts of the specified subtree, annotating the parts using the Simplifier.Annotation annotation.

Reduce all subtrees annotated with Simplifier.Annotation found within the document.

Reduce the sub trees annotated with Simplifier.Annotation found within the subtrees identified with the specified annotation.

Reduce the sub trees annotated with Simplifier.Annotation found within the specified span.

Reduce the sub trees annotated with Simplifier.Annotation found within the specified spans.

An annotation that holds onto information about a type or namespace symbol.

A service that knows how to convert semantic version to project version

A workspace that allows manual addition of projects and documents.

Clears all projects and documents from the workspace.

Adds an entire solution to the workspace, replacing any existing solution.

Adds a project to the workspace. All previous projects remain intact.

Adds multiple projects to the workspace at once. All existing projects remain intact.

Adds a document to the workspace.

Cost based cache with elastic upper bound. This cache has two distinct characteristics where it will try to keep actively referenced entries as long as possible but also tries to keep more data in the cache if there is a sudden flood of data coming in. The first part is achieved by giving more weight on items that are more frequently accessed. But also by gradually retiring them once they are not accessed, it should give space back to newer data. The second part is achieved by increasing the size of the upper bound of the cache when there is a sudden increase in the rate of data coming into the cache. the size of the upper bound will be decreased to its normal level once those activities have ceased.

This interface is provided purely to enable some shared logic that handles multiple kinds of metadata that share the Languages property. It should not be used to find exports via MEF, use LanguageMetadata instead.

The layer of an exported service. If there are multiple definitions of a service, the is used to determine which is used. Editor overrides Default Host overrides Editor and Default

Use this attribute to declare a implementation for inclusion in a MEF-based workspace.

The assembly qualified name of the service's type.

The language that the service is target for; LanguageNames.CSharp, etc.

The layer that the service is specified for; ServiceLayer.Default, etc.

Declares a implementation for inclusion in a MEF-based workspace.

The type that will be used to retrieve the service from a . The language that the service is target for; LanguageNames.CSharp, etc. The layer that the service is specified for; ServiceLayer.Default, etc.

Use this attribute to declare a implementation for inclusion in a MEF-based workspace.

The assembly qualified name of the service's type.

The language that the service is target for; LanguageNames.CSharp, etc.

The layer that the service is specified for; ServiceLayer.Default, etc.

Declares a implementation for inclusion in a MEF-based workspace.

This interface is provided purely to enable some shared logic that handles multiple kinds of metadata that share the Language property. It should not be used to find exports via MEF, use LanguageMetadata instead.

A factory that creates instances of a specific . Implement a when you want to provide instances that use other services.

Creates a new instance.

The that can be used to access other services.

MEF metadata class used to find exports declared for a specific language.

MEF metadata class used for finding and exports.

Use this attribute to declare a implementation for inclusion in a MEF-based workspace.

The assembly qualified name of the service's type.

The layer that the service is specified for; ServiceLayer.Default, etc.

Declares a implementation for inclusion in a MEF-based workspace.

The type that will be used to retreive the service from a . The layer that the service is specified for; ServiceLayer.Default, etc.

Use this attribute to declare a implementation for inclusion in a MEF-based workspace.

The assembly qualified name of the service's type.

The layer that the service is specified for; ServiceLayer.Default, etc.

Declares a implementation for inclusion in a MEF-based workspace.

The type that will be used to retreive the service from a . The layer that the service is specified for; ServiceLayer.Default, etc.

A factory that creates instances of a specific . Implement a when you want to provide instances that use other services.

Creates a new instance.

The that can be used to access other services.

MEF metadata class used for finding and exports.

Represents all the state used by a language-specific recoverable syntax tree

Called by the constructor the parent tree.

This is to address the catch-22 dependency -- a tree needs it's recoverable root and vice versa. The dangerous bit is when we call TickleCache because it's the first place when this tree gets handed out to another system. We need to make sure both this object and the parent tree are fully constructed by that point.

Empty interface just to mark language services.

Factory service for creating syntax trees.

An object cache controls the lifetime of an object by holding a reference to it, keeping the garbage collector from collecting it. The cache uses a heuristic to determine how many objects to keep alive, which to evict from the cache and when to evict them.

Add an object to the cache, or notify the cache that the object was recently used.

The object to add or notify. An action to take when the object is evicted. True if the instance was added.

Clear the cache.

called when data stored in the cache is evicted.

This class is a ValueSource that manages storing an item in a cache, saving the item's state when it is evicted from the cache and recovering it from its saved state when the value source is accessed again.

Override this to save the state of the instance so it can be recovered. This method will only ever be called once.

Override this method to implement asynchronous recovery semantics. This method may be called multiple times.

Override this method to implement synchronous recovery semantics. This method may be called multiple times.

Per language services provided by the host environment.

The that originated this language service.

The name of the language

Gets a language specific service provided by the host identified by the service type. If the host does not provide the service, this method returns null.

A factory for creating compilations instances.

Services provided by the host environment.

Creates a new workspace service.

caller should make sure this is called in a thread-safe way

This service allows you to persist information relative to solution, projects and documents.

A service that enables storing and retrieving of information associated with solutions, projects or documents across runtime sessions.

An abstraction for running tasks either in sequence or in parallel.

Execute the task action on a thread owned by a task scheduler.

Execute the task function on a thread owned by a task scheduler and return the schedule task that can be used to wait for the result.

A factory that creates either sequential or parallel task schedulers.

Creates a workspace task scheduler that schedules tasks to run in parallel.

Creates a workspace task scheduler that schedules task to run in sequence.

support direct memory access pointer

TemporaryStorage can be used to read and write text to a temporary storage location.

This service allows you to access temporary storage.

A factory for creating instances.

Creates from a stream.

The stream to read the text from. Must be readable and seekable. The text is read from the start of the stream. Specifies an encoding to be used if the actual encoding can't be determined from the stream content (the stream doesn't start with Byte Order Mark). If not specified auto-detect heristics are used to determine the encoding. If these heristics fail the decoding is assumed to be the system encoding. Note that if the stream starts with Byte Order Mark the value of is ignored. Cancellation token. The stream content can't be decoded using the specified , or is null and the stream appears to be a binary file. An IO error occured while reading from the stream.

Per workspace services provided by the host environment.

The host services this workspace services originated from.

The workspace corresponding to this workspace services instantiation

A service for storing information across that can be retrieved in a separate process.

A service for storing information in a temporary location that only lasts for the duration of the process.

A factory that constructs .

A list of language names for supported language services.

Returns true if the language is supported.

Gets the for the language name.

Finds all language services of the corresponding type across all supported languages that match the filter criteria.

Empty interface just to mark workspace services.

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 tree/sequence #1.

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

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.

Returns a distance [0..1] of the specified sequences. The smaller distance the more of their elements match.

Calculates costs of all paths in an edit graph starting from vertext (0,0) and ending in vertex (lengthA, lengthB).

The edit graph for A and B 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. Editing starts with S = []. Move along horizontal edge (i-1,j)-(i,j) represents the fact that sequenceA[i-1] is not added to S. Move along vertical edge (i,j-1)-(i,j) represents an insert of sequenceB[j-1] to S. Move along diagonal edge (i-1,j-1)-(i,j) represents an addition of sequenceB[j-1] to S via an acceptable change of sequenceA[i-1] to sequenceB[j-1]. In every vertex the cheapest outgoing edge is selected. The number of diagonal edges on the path from (0,0) to (lengthA, lengthB) is the length of the longest common subsequence.

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.

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.

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

Dependent projects cache. For a given solution, maps from an assembly (source/metadata) to the set of projects referencing it. Key: DefinitionProject, which contains the assembly name and a flag indicating whether assembly is source or metadata assembly. Value: List of DependentProjects, where each DependentProject contains a dependent project ID and a flag indicating whether the dependent project has internals access to definition project.

Used to create a new concurrent dependent projects map for a given assembly when needed.

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: 1) Public: Dependent projects include the symbol definition project and all the referencing projects. 2) Internal: Dependent projects include the symbol definition project and all the referencing projects that have internals access to the definition project. 3) 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: 1) Compute all the dependent projects (submission + non-submission) and their InternalsVisibleTo semantics to the definition project. 2) Filter the above computed dependent projects based on symbol visibility. Dependent projects computed in stage (1) are cached to avoid recomputation.

This method creates an initial cheap InternalsVisibleTo map from the given to the assembly names that have friend access to this assembly. This map is a superset of the actual InternalsVisibleTo map and is used for performance reasons only. While identifying depend projects that can reference a given symbol (see method ), we need to know a symbol's accessibility from referencing projects. This requires us to create a compilation for the referencing project just to check accessibility and can be performance intensive. Instead, we crack the assembly attributes just for the symbol's containing assembly here to enable cheap checks for friend assemblies in .

Provides helper methods for finding dependent types (derivations, implementations, etc.) across a solution.

This type makes heavy use of for caching purposes. When modifying these caches, care must be taken to avoid introducing memory leaks. Instances of are used as the keys in these caches, so in general only symbols or other data from that same compilation should be stored in the associated value.

For a given , stores a flat list of all the source types and all the accessible metadata types within the compilation.

For a given , stores a flat list of all the source types.

A predicate for determining if one class derives from another. Static to avoid unnecessary allocations.

For a given , maps from a class (from the compilation or one of its dependencies) to the set of classes in the compilation that derive from it.

s are used instead of s to avoid keeping other compilations alive unnecessarily.

A predicate for determining if one interface derives from another. Static to avoid unnecessary allocations.

For a given , maps from an interface (from the compilation or one of its dependencies) to the set of interfaces in the compilation that derive from it.

s are used instead of s to avoid keeping other compilations alive unnecessarily.

A predicate for determining if a class implements an interface. Static to avoid unnecessary allocations.

For a given , maps from an interface (from the compilation or one of its dependencies) to the set of types in the compilation that implement it.

s are used instead of s to avoid keeping other compilations alive unnecessarily.

Used by the cache to compare s used as keys in the cache. We make sure to check the casing of names and assembly IDs during the comparison, in order to be as discriminating as possible.

Used to create a new concurrent map for a given compilation when needed.

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

Extensibility interface to allow extending the IFindReferencesService service. Implementations must be threadsafe 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.

Called by the find references search engine to determine which projects should be searched for a given symbol. The returned projects will then be searched in parallel. If the implementation does not care about the provided symbol then null can be returned from this method. Implementations should endeavor to keep the list of returned projects as small as possible to keep search time down to a minimum. Returning the entire list of projects in a solution is not recommended (unless, of course, there is reasonable reason to believe there are references in every project). Implementations of this method must be threadsafe.

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 threadsafe.

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 threadsafe.

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 threadsafe.

The list of common reference finders.

A class that reports the current progress made when finding references to symbols.

Mapping from a document to the list of reference locations found in it. Kept around so we only notify the callback once when a location is found for a reference (in case multiple finders find the same reference location for a symbol).

The resultant collection of all references found per symbol.

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.

The set of reference locations in the solution.

Internal for testing purposes

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 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 "Foo()" could show up as an error tolerance location to a method "Foo(int i)" if no actual "Foo()" method existed.

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.

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 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 complilation may or may not be the origin of the symbol. A CancellationToken.

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

Makes certain all namespace symbols returned by API are from the compilation.

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

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

Find symbols for members that override the specified member symbol.

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

Finds the symbols that implement an interface or interface member.

Finds all the callers of a specified symbol.

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.

The list of nodes that represent symbols. The primary key into the sorting of this list is the name. They are sorted case-insensitively with the . 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.

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

Gets all the node indices with matching names per the .

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

Get all symbols that have a matching name as determined by the predicate.

this gives you SymbolTreeInfo for a project

this gives you SymbolTreeInfo for a metadata

A node represents a single unique name in a dotted-name tree. Uniqueness is always case sensitive.

this is for a project in a solution

this is for a metadata reference in a solution

hold context info in memory. since context info is quite small (less than 30 bytes per a document), holding this in memory should be fine.

in memory cache will hold onto any info related to opened documents in primary branch or all documents in forked branch this is not snapshot based so multiple versions of snapshots can re-use same data as long as it is relevant.

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).

snapshot based cache to guarantee same info is returned without re-calculating for same solution snapshot. since document will be re-created per new solution, this should go away as soon as there is any change on workspace.

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.

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.

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

rewrite the node with the given trivia information in the map

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

a delegate cache for a continuation style chaining

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

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.

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.

base IFormattingRule implementation that users can override to provide their own functionality

Specifies the exact type of the formatting rule exported

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

All methods defined in this interface 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

a delegate cache for a continuation style chaining

Represents a next operation to run in a continuation style chaining.

indicate how many lines are needed between two tokens

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

indicate how many spaces are needed between two spaces

Options for AdjustSpacesOperation.

Preserve spaces as it is

DefaultSpacesIfOnSingleLine 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.

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

ForceSpaces 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 AlignTokensOperation 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 start token will act as anchor token and 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 SuppressOperation for the node provided by the given formatting rules

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 IndentBlockOperation

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

IndentationDeltaOrPosition will be interpreted as delta of its enclosing indentation

IndentationDeltaOrPosition will be interpreted as absolute position

Mask for relative position options

Mask for position options

suppress formatting operations within the given text span

Options for SuppressOperation NoWrappingIfOnSingleLine means no wrapping if given tokens are on same line NoWrapping means no wrapping regardless of relative positions of two tokens NoSpacing means no spacing regardless of relative positions of two tokens

concurrent task executor

synchronous executor

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

check whether given string is either null or whitespace

check whether given char is whitespace

check whether given char is new line char

convert common syntax trivia to SyntaxTrivia

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

This interface exists purely to enable some shared code that operates over orderable metadata. This interface should not be used directly with MEF, used OrderableMetadata instead.

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

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.

Returns true if the given character is a character which may be included in an identifier to specify the type of a variable.

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.

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.

a service which will never raise start event

raised when global operation is started

raised when global operation is stopped

start new global operation

Provides services for reading and writing options.

Gets the current value of the specific option.

Fetches an immutable set of all current options.

Applies a set of options.

Returns the set of all registered options.

An global option. An instance of this class can be used to access an option value from an OptionSet.

Feature this option is associated with.

The name of the option.

The type of the option value.

The default value of the option.

Gets the value of the option.

Creates a new that contains the changed value.

Gets a list of all the options that were accessed.

An option that can be specified once per language.

Feature this option is associated with.

The name of the option.

The type of the option value.

The default option value.

Exportable by a host to specify the save and restore behavior for a particular set of values.

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 if this identifier represents an accessor. E.g. get_Foo (of property Foo).

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 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 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

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.

The result of the conflict engine. Once this object is returned from the engine, it is immutable.

The list of all symbol locations that are referenced either by the original symbol or the renamed symbol. This includes both resolved and unresolved conflicts.

The list of all document ids of documents that have been touched for this rename operation.

The new workspace snapshot

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.

Performs the renaming of the symbol in the solution, identifies renaming conflicts and automatically resolves them where possible.

The locations to perform the renaming at. The original name of the identifier. The new name of the identifier The option for rename The cancellation token. A conflict resolution containing the new solution.

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.

Gives information about an identifier span that was affected by Rename (Reference or Non reference)

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 Foo is an extension method: "a.Foo(a)" is rewritten to "NS1.NS2.Foo(NS3.a, NS3.a)" The OriginalSpan is the span of "a.Foo(a)" The NewSpan is the span of "NS1.NS2.Foo(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" "Foo", "NS1.NS2.Foo" "a", "NS3.a"

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 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

A helper class that contains some of the methods and filters that must be used when processing the raw results from the FindReferences API.

Holds the ILocations of a symbol that should be renamed, along with the symbol and Solution for the set.

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.

Given a ISymbol, returns the renamable locations for a given symbol.

Find the locations that need to be renamed.

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 Document extension method GetSemanticModelForNodeAsync or GetSemanticModelForSpanAsync instead. see the descriptions on the extension methods

A SymbolKey is a lightweight identifier for a symbol that can be used to resolve the "same" symbol across compilations. Different symbols have different concepts of "same-ness". Same-ness is recursively defined as follows: Two IArraySymbol's are the "same" if they have the "same" element type and the same rank. Two IAssemblySymbol's are the "same" if they have the same . Two IEventSymbol's are the "same" if they have the "same" containing type and the same . Two IMethodSymbol's are the "same" if they have the "same" containing type, the same , the same , the "same" , and have same parameter types and . IModuleSymbol's are the "same" if they have the same containing assembly. is not used because module identity is not important in practice. Two INamedTypeSymbol's are the "same" if they have "same" containing symbol, the same , the same and the "same" . Two INamespaceSymbol's are the "same" if they have the "same" containing symbol and the same . If the INamespaceSymbol is the global namespace for a compilation (and thus does not have a containing symbol) then it will only match another global namespace of another compilation. Two IParameterSymbol's are the "same" if they have the "same" containing symbol and the . Two IPointerTypeSymbol's are the "same" if they have the "same" . Two IPropertySymbol's are the "same" if they have the "same" containing type, the same , and have same parameter types and . Two ITypeParameterSymbol's are the "same" if they have the "same" containing symbol and the . Two IFieldSymbol's are the "same" if they have the "same" containing symbol and the . A SymbolID for an IAliasSymbol will back to the ISymbol for the . Due to issues arising from errors and ambiguity, it's possible for a SymbolKey to resolve to multiple symbols. For example, in the following type:


            class C
            {
               int Foo();
               bool Foo();
            }

The SymbolKey for both Foo methods will be the same. The SymbolId will then resolve to both methods.

This entry point should only be called from the actual Symbol classes. It should not be used internally inside this type. Instead, any time we need to get the for a related symbol (i.e. the containing namespace of a namespace) we should call . The benefit of this is twofold. First of all, it keeps the size of the small by allowing up to reuse parts we've already created. For example, if we have the for Foo(int, int), then we will reuse the s for both ints. Second, this allows us to deal with the recursive nature of MethodSymbols and TypeParameterSymbols. Specifically, a MethodSymbol is defined by its signature. However, it's signature may refer to type parameters of that method. Unfortunately, the type parameters depend on their containing method. For example, if there is (T t)]]>, then we must avoid the situation where we: try to get the symbol ID for the type parameter T, which in turn tries to get the symbol ID for the method T, which in turn tries to get the symbol IDs for the parameter types, which in turn tries to get the symbol ID for the type parameter T, which leads back to 1 and infinitely loops. In order to break this circularity we do not create the SymbolIDs for a method's type parameters directly in the visitor. Instead, we create the SymbolID for the method itself. When the MethodSymbolId is created it will directly instantiate the SymbolIDs for the type parameters, and directly assign the type parameter's method ID to itself. It will also then directly store the mapping from the type parameter to its SymbolID in the visitor cache. Then when we try to create the symbol IDs for the parameter types, any reference to the type parameters can be found in the cache. It is for this reason that it is essential that all calls to get related symbol IDs goes through GetOrCreate and not Create.

When comparing symbols we need to handle recursion between method type parameters and methods. For example, if we have two methods with the signature (T t)]]> and we try to test for equality we must avoid the situation where we: First test if the methods are the same, which will in turn test if the method's parameter types are the same, which will in turn test if the type parameters are the same, which will in turn test if the methods are the same, which causes infinite recursion. To avoid this we distinguish the cases where we're testing if two type parameters actually refer to the same thing, versus type parameters being referenced by parameters. For example, if we have:

(T t) 
            Bar(T t) 
            ]]>

then clearly the type parameter T in ]]> is different from the type parameter T in ]]>. When testing these type parameters for equality we *will* test to see if they have the same parent. This will end up returning false, and so we will consider them different. However, when we are testing if two signatures are the same, if we hit a method type parameter then we only need to compare by metadataName. That's because we know we'll already have checked if the method and it's parents are the same, so we don't need to recurse through them again.

Represents a non source code file.

Create a stream from a . should be non-null.

Resolved path of the stream.

Opens a that allows reading the content of this file.

solution branch Id

Represents a source code document that is part of a project. It provides access to the source text, parsed syntax tree and the corresponding semantic model.

The kind of source code this document contains.

Get the current syntax tree for the document if the text is already loaded and the tree is already parsed. Returns true if the syntax tree is already available, or false if getting the syntax tree would have incurred additional work.

Get the current syntax tree version for the document if the text is already loaded and the tree is already parsed. Returns true if the syntax tree is already available, or false if getting the syntax tree would have incurred additional work.

Gets the version of the document's top level signature if it is already loaded and available.

Gets the version of the syntax tree. This is generally the newer of the text version and the project's version.

true if this Document supports providing data through the and methods. If false then these methods will return null instead.

true if this Document supports providing data through the method. If false then this method will return null instead.

Gets the for this document asynchronously.

Gets the root node of the current syntax tree if it is available.

Gets the root node of the syntax tree asynchronously.

Gets the current semantic model for this document if the model is already computed.

Gets the semantic model for this document asynchronously.

Creates a new instance of this document updated to have the source code kind specified.

Creates a new instance of this document updated to have the text specified.

Creates a new instance of this document updated to have a syntax tree rooted by the specified syntax node.

Get the text changes between this document and a prior version of the same document. The changes, when applied to the text of the old document, will produce the text of the current document.

Gets the list of s that are linked to this . s are considered to be linked if they share the same . This is excluded from the result.

Creates a branched version of this document that has its semantic model frozen in whatever state it is available at the time, assuming a background process is constructing the semantics asynchronously. Repeated calls to this method may return documents with increasingly more complete semantics. Use this method to gain access to potentially incomplete semantics quickly.

An identifier that can be used to retrieve the same across versions of the workspace.

Creates a new instance.

The project id this document id is relative to. An optional name to make this id easier to recognize while debugging.

A class that represents all the arguments necessary to create a new document instance.

The Id of the document.

The name of the document.

The names of the logical nested folders the document is contained in.

The kind of the source code.

The file path of the document.

Specifies an encoding to be used if the actual encoding of the file can't be determined from the stream content (the stream doesn't start with Byte Order Mark). If null auto-detect heristics are used to determine the encoding. If these heristics fail the decoding is assumed to be the system encoding. Note that if the stream starts with Byte Order Mark the value of is ignored.

A loader that can retrieve the document text.

True if the document is a side effect of the build.

Create a new instance of a .

The mode in which value is preserved.

The value is guaranteed to have the same contents across multiple accesses.

The value is guaranteed to the same instance across multiple accesses.

Represents a project that is part of a .

The solution this project is part of.

The ID of the project. Multiple instances may share the same ID. However, only one project may have this ID in any given solution.

The path to the project file or null if there is no project file.

The path to the output file, or null if it is not known.

true if this supports providing data through the method. If false then this method will return null instead.

The language services from the host environment associated with this project's language.

The language associated with the project.

The name of the assembly this project represents.

The name of the project. This may be different than the assembly name.

The list of all other metadata sources (assemblies) that this project references.

The list of all other projects within the same solution that this project references.

The list of all other projects that this project references, including projects that are not part of the solution.

The list of all the diagnostic analyzer references for this project.

The options used by analyzers for this project.

The options used when building the compilation for this project.

The options used when parsing documents for this project.

Returns true if this is a submission project.

True if the project has any documents.

All the document IDs associated with this project.

All the additional document IDs associated with this project.

All the documents associated with this project.

True if the project contains a document with the specified ID.

True if the project contains an additional document with the specified ID.

Get the documentId in this project with the specified syntax tree.

Get the document in this project with the specified syntax tree.

Get the document in this project with the specified document Id.

Get the additional document in this project with the specified document Id.

Get the for this project if it is available.

Get the for this project asynchronously.

Gets an object that lists the added, changed and removed documents between this project and the specified project.

The project version. This equates to the version of the project file.

The version of the most recently modified document.

The most recent version of the project, its documents and all dependent projects and documents.

The semantic version of this project including the semantics of referenced projects. This version changes whenever the consumable declarations of this project and/or projects it depends on change.

The semantic version of this project not including the semantics of referenced projects. This version changes only when the consumable declarations of this project change.

Creates a new instance of this project updated to have the new assembly name.

Creates a new instance of this project updated to have the specified compilation options.

Creates a new instance of this project updated to have the specified parse options.

Creates a new instance of this project updated to include the specified project reference in addition to already existing ones.

Creates a new instance of this project updated to include the specified project references in addition to already existing ones.

Creates a new instance of this project updated to no longer include the specified project reference.

Creates a new instance of this project updated to replace existing project references with the specified ones.

Creates a new instance of this project updated to include the specified metadata reference in addition to already existing ones.

Creates a new instance of this project updated to include the specified metadata references in addition to already existing ones.

Creates a new instance of this project updated to no longer include the specified metadata reference.

Creates a new instance of this project updated to replace existing metadata reference with the specified ones.

Creates a new instance of this project updated to include the specified analyzer reference in addition to already existing ones.

Creates a new instance of this project updated to include the specified analyzer references in addition to already existing ones.

Creates a new instance of this project updated to no longer include the specified analyzer reference.

Creates a new instance of this project updated to replace existing analyzer references with the specified ones.

Creates a new document in a new instance of this project.

Creates a new instance of this project updated to no longer include the specified document.

A models the dependencies between projects in a solution.

Gets the list of projects (topologically sorted) that this project directly depends on.

Gets the list of projects (topologically sorted) that directly depend on this project.

Gets the list of projects that directly or transitively this project depends on

Gets the list of projects that directly or transitively depend on this project.

Returns all the projects for the solution in a topologically sorted order with respect to their dependencies. Projects that depend on other projects will always show up later in this sequence than the projects they depend on.

Returns a sequence of sets, where each set contains items with shared interdependency, and there is no dependency between sets.

An identifier that can be used to refer to the same across versions.

The system generated unique id.

Create a new ProjectId instance.

An optional name to make this id easier to recognize while debugging.

A class that represents all the arguments necessary to create a new project instance.

The unique Id of the project.

The version of the project.

The name of the project. This may differ from the project's filename.

The name of the assembly that this project will create, without file extension.

The language of the project.

The path to the project file or null if there is no project file.

The path to the output file (module or assembly).

The initial compilation options for the project, or null if the default options should be used.

The initial parse options for the source code documents in this project, or null if the default options should be used.

The list of source documents initially associated with the project.

The project references initially defined for the project.

The metadata references initially defined for the project.

The analyzers initially associated with this project.

The list of non-source documents associated with this project.

True if this is a submission project for interactive sessions.

Type of the host object.

Create a new instance of a ProjectInfo.

The project this document belongs to.

The document's identifier. Many document instances may share the same ID, but only one document in a solution may have that ID.

The path to the document file or null if there is no document file.

The name of the document.

The sequence of logical folders the document is contained in.

Get the current text for the document if it is already loaded and available.

Gets the version of the document's text if it is already loaded and available.

Gets the current text for the document asynchronously.

Gets the version of the document's text.

Gets the version of the document's top level signature.

A text retainer that will save text to temporary storage when it is evicted from the text cache and reload from that storage if and when it is needed again.

Represents a set of projects and their source code documents.

Tracks the changes made to a project and provides the facility to get a lazily built compilation for that project. As the compilation is being built, the partial results are stored as well so that they can be used in the 'in progress' workspace snapshot.

Access via the and methods.

Creates a tracker for the provided project. The tracker will be in the 'empty' state and will have no extra information beyond the project itself.

Returns true if this tracker currently either points to a compilation, has an in-progress compilation being computed, or has a skeleton reference. Note: this is simply a weak statement about the tracker at this exact moment in time. Immediately after this returns the tracker might change and may no longer have a final compilation (for example, if the retainer let go of it) or might not have an in-progress compilation (for example, if the background compiler finished with it). Because of the above limitations, this should only be used by clients as a weak form of information about the tracker. For example, a client may see that a tracker has no compilation and may choose to throw it away knowing that it could be reconstructed at a later point if necessary.

Creates a new instance of the compilation info, retaining any already built compilation state as the now 'old' state

Creates a fork with the same final project.

Tries to get the latest snapshot of the compilation without waiting for it to be fully built. This method takes advantage of the progress side-effect produced during BuildCompilation. It will either return the already built compilation, any in-progress compilation or any known old compilation in that order of preference. The compilation state that is returned will have a compilation that is retained so that it cannot disappear.

Gets the final compilation if it is available.

Builds the compilation matching the project state. In the process of building, also produce in progress snapshots that can be accessed from other threads.

Get a metadata reference to this compilation info's compilation with respect to another project. For cross language references produce a skeletal assembly. If the compilation is not available, it is built. If a skeletal assembly reference is needed and does not exist, it is also built.

Attempts to get (without waiting) a metadata reference to a possibly in progress compilation. Actual compilation references are preferred over skeletal assembly references. Could potentially return null if nothing can be provided.

Gets a metadata reference to the metadata-only-image corresponding to the compilation.

Converts a compilation into a ValueSource employing an external compilation retention policy.

branch id of this solution currently, it only supports one level of branching. there is a primary branch of a workspace and all other branches that are branched from the primary branch. one still can create multiple forked solutions from an already branched solution, but versions among those can't be reliably used and compared. version only has a meaning between primary solution and branched one or between solutions from same branch.

The Workspace this solution is associated with.

The Id of the solution. Multiple solution instances may share the same Id.

The path to the solution file or null if there is no solution file.

The solution version. This equates to the solution file's version.

A list of all the ids for all the projects contained by the solution.

A list of all the projects contained by the solution.

The version of the most recently modified project.

True if the solution contains a project with the specified project ID.

Gets the project in this solution with the specified project ID. If the id is not an id of a project that is part of this solution the method returns null.

Gets the associated with an assembly symbol.

True if the solution contains the document in one of its projects

True if the solution contains the additional document in one of its projects

Gets the documentId in this solution with the specified syntax tree.

Gets the document in this solution with the specified document ID.

Gets the additional document in this solution with the specified document ID.

Gets the document in this solution with the specified syntax tree.

Creates a new solution instance that includes a project with the specified language and names. Returns the new project.

Creates a new solution instance that includes a project with the specified language and names.

Create a new solution instance that includes a project with the specified project information.

Create a new solution instance without the project specified.

Creates a new solution instance with the project specified updated to have the new assembly name.

Creates a new solution instance with the project specified updated to have the output file path.

Creates a new solution instance with the project specified updated to have the name.

Creates a new solution instance with the project specified updated to have the project file path.

Create a new solution instance with the project specified updated to have the specified compilation options.

Create a new solution instance with the project specified updated to have the specified parse options.

Create a new solution instance with the project specified updated to include the specified project reference.

Create a new solution instance with the project specified updated to include the specified project references.

Create a new solution instance with the project specified updated to no longer include the specified project reference.

Create a new solution instance with the project specified updated to contain the specified list of project references.

Create a new solution instance with the project specified updated to include the specified metadata reference.

Create a new solution instance with the project specified updated to include the specified metadata references.

Create a new solution instance with the project specified updated to no longer include the specified metadata reference.

Create a new solution instance with the project specified updated to include only the specified metadata references.

Create a new solution instance with the project specified updated to include the specified analyzer reference.

Create a new solution instance with the project specified updated to include the specified analyzer references.

Create a new solution instance with the project specified updated to no longer include the specified analyzer reference.

Create a new solution instance with the project specified updated to include only the specified analyzer references.

Creates a new solution instance with the corresponding project updated to include a new document instance defined by its name and text.

Creates a new solution instance with the project updated to include a new document with the arguments specified.

Create a new solution instance with the corresponding project updated to include a new document instanced defined by the document info.

Creates a new solution instance with the corresponding project updated to include a new additional document instance defined by its name and text.

Creates a new solution instance that no longer includes the specified document.

Creates a new solution instance that no longer includes the specified additional document.

Creates a new solution instance with the document specified updated to be contained in the sequence of logical folders.

Creates a new solution instance with the document specified updated to have the text specified.

Creates a new solution instance with the additional document specified updated to have the text specified.

Creates a new solution instance with the document specified updated to have the text and version specified.

Creates a new solution instance with the additional document specified updated to have the text and version specified.

Creates a new solution instance with the document specified updated to have a syntax tree rooted by the specified syntax node.

Creates a new solution instance with the document specified updated to have the source code kind specified.

Creates a new solution instance with the document specified updated to have the text supplied by the text loader.

Creates a new solution instance with the additional document specified updated to have the text supplied by the text loader.

Creates a new snapshot with an updated project and an action that will produce a new compilation matching the new project out of an old compilation. All dependent projects are fixed-up if the change to the new project affects its public metadata, and old dependent compilations are forgotten.

Gets the set of s in this with a that matches the given file path.

Gets a copy of the solution isolated from the original so that they do not share computed state. Use isolated solutions when doing operations that are likely to access a lot of text, syntax trees or compilations that are unlikely to be needed again after the operation is done. When the isolated solution is reclaimed so will the computed state.

Creates a branch of the solution that has its compilations frozen in whatever state they are in at the time, assuming a background compiler is busy building this compilations. A compilation for the project containing the specified document id will be guaranteed to exist with at least the syntax tree for the document. This not intended to be the public API, use Document.WithFrozenPartialSemantics() instead.

Creates a new solution instance with all the documents specified updated to have the same specified text.

Get a metadata reference for the project's compilation

Attempt to get the best readily available compilation for the project. It may be a partially built compilation.

Gets an objects that lists the added, changed and removed projects between this solution and the specified solution.

Gets an ProjectDependencyGraph that details the dependencies between projects for this solution.

An identifier that can be used to refer to the same Solution across versions.

The unique id of the solution.

Create a new Solution Id

An optional name to make this id easier to recognize while debugging.

A class that represents all the arguments necessary to create a new solution instance.

The unique Id of the solution.

The version of the solution.

The path to the solution file, or null if there is no solution file.

A list of projects initially associated with the solution.

Create a new instance of a SolutionInfo.

This class basically holds onto a set of services and gets reused across solution instances.

A class that represents both a source text and its version stamp.

The source text.

The version of the source text

An optional file path that identifies the origin of the source text

Create a new TextAndVersion instance.

The text The version An optional file path that identifies the original of the source text.

A class that represents access to a source text and its version from a storage location.

Creates a new TextLoader from an already existing source text and version.

Creates a TextLoader from a SourceTextContainer and version. The text obtained from the loader will be the current text of the container at the time the loader is accessed.

A class that represents both a tree and its top level signature version

The syntax tree

The version of the top level signature of the tree

VersionStamp should be only used to compare versions returned by same API.

global counter to avoid collision within same session. it starts with a big initial number just for a clarity in debugging

time stamp

indicate whether there was a collision on same item

unique version in same session

Creates a new instance of a VersionStamp.

Creates a new instance of a version stamp based on the specified DateTime.

compare two different versions and return either one of the versions if there is no collision, otherwise, create a new version that can be used later to compare versions between different items

Gets a new VersionStamp that is guaranteed to be newer than its base one this should only be used for same item to move it to newer version

Returns the serialized text form of the VersionStamp.

check whether given persisted version is re-usable

True if this VersionStamp is newer than the specified one.

Gets the documents from the corresponding workspace's current solution that are associated with the source text's container, updated to contain the same text as the source if necessary.

Gets the document from the corresponding workspace's current solution that is associated with the source text's container in its current project context, updated to contain the same text as the source if necessary.

Gets the documents from the corresponding workspace's current solution that are associated with the text container.

Gets the document from the corresponding workspace's current solution that is associated with the text container in its current project context.

A workspace provides access to a active set of source code projects and documents and their associated syntax trees, compilations and semantic models. A workspace has a current solution that is an immutable snapshot of the projects and documents. This property may change over time as the workspace is updated either from live interactions in the environment or via call to the workspace's method.

Constructs a new workspace instance.

The this workspace uses A string that can be used to identify the kind of workspace. Usually this matches the name of the class.

Services provider by the host for implementing workspace features.

primary branch id that current solution has

Override this property if the workspace supports partial semantics for documents.

The kind of the workspace. This is generally if originating from the host environment, but may be any other name used for a specific kind of workspace.

Create a new empty solution instance associated with this workspace.

The current solution. The solution is an immutable model of the current set of projects and source documents. It provides access to source text, syntax trees and semantics. This property may change as the workspace reacts to changes in the environment or after is called.

Set's the of this workspace. This method does not raise a workspace change event.

Gets or sets the set of all global options.

Executes an action as a background task, as part of a sequential queue of tasks.

Execute a function as a background task, as part of a sequential queue of tasks.

Override this method to act immediately when the text of a document has changed, as opposed to waiting for the corresponding workspace changed event to fire asynchronously.

Override this method to act immediately when a document is closing, as opposed to waiting for the corresponding workspace changed event to fire asynchronously.

Clears all solution data and empties the current solution.

This method is called when a solution is cleared. Override this method if you want to do additional work when a solution is cleared. Call the base method at the end of your method.

This method is called when an individual project is removed. Override this method if you want to do additional work when a project is removed. Call the base method at the end of your method.

This method is called to clear an individual document is removed. Override this method if you want to do additional work when a document is removed. Call the base method at the end of your method.

Disposes this workspace. The workspace can longer be used after it is disposed.

Call this method when the workspace is disposed. Override this method to do addition work when the workspace is disposed. Call this method at the end of your method.

Call this method to respond to a solution being opened in the host environment.

Call this method to respond to a solution being reloaded in the host environment.

This method is called when the solution is removed from the workspace. Override this method if you want to do additional work when the solution is removed. Call the base method at the end of your method. Call this method to respond to a solution being removed/cleared/closed in the host environment.

Call this method to respond to a project being added/opened in the host environment.

Call this method to respond to a project being reloaded in the host environment.

Call this method to respond to a project being removed from the host environment.

Call this method when a project's assembly name is changed in the host environment.

Call this method when a project's output file path is changed in the host environment.

Call this method when a project's name is changed in the host environment.

Call this method when a project's compilation options are changed in the host environment.

Call this method when a project's parse options are changed in the host environment.

Call this method when a project reference is added to a project in the host environment.

Call this method when a project reference is removed from a project in the host environment.

Call this method when a metadata reference is added to a project in the host environment.

Call this method when a metadata reference is removed from a project in the host environment.

Call this method when an analyzer reference is added to a project in the host environment.

Call this method when an analyzer reference is removed from a project in the host environment.

Call this method when a document is added to a project in the host environment.

Call this method when a document is reloaded in the host environment.

Call this method when a document is removed from a project in the host environment.

Call this method when the text of a document is changed on disk.

Call this method when the text of a document is updated in the host environment.

Call this method when the SourceCodeKind of a document changes in the host environment.

Call this method when an additional document is added to a project in the host environment.

Call this method when an additional document is removed from a project in the host environment.

Determines if the specific kind of change is supported by the method.

Apply changes made to a solution back to the workspace. The specified solution must be one that originated from this workspace. If it is not, or the workspace has been updated since the solution was obtained from the workspace, then this method returns false.

This method is called during for each project that has been added, removed or changed. Override this method if you want to modify how project changes are applied.

This method is called during to add a project reference to a project. Override this method to implement the capability of adding project references.

This method is called during to remove a project reference from a project. Override this method to implement the capability of removing project references.

This method is called during to add a metadata reference to a project. Override this method to implement the capability of adding metadata references.

This method is called during to remove a metadata reference from a project. Override this method to implement the capability of removing metadata references.

This method is called during to add an analyzer reference to a project. Override this method to implement the capability of adding analyzer references.

This method is called during to remove an analyzer reference from a project. Override this method to implement the capability of removing analyzer references.

This method is called during to add a new document to a project. Override this method to implement the capability of adding documents.

This method is called during to remove a document from a project. Override this method to implement the capability of removing documents.

This method is called to change the text of a document. Override this method to implement the capability of changing document text.

This method is called during to add a new additional document to a project. Override this method to implement the capability of adding additional documents.

This method is called during to remove an additional document from a project. Override this method to implement the capability of removing additional documents.

This method is called to change the text of an additional document. Override this method to implement the capability of changing additional document text.

Throws an exception is the solution is not empty.

Throws an exception if the project is not part of the current solution.

Throws an exception is the project is part of the current solution.

Throws an exception if a project does not have a specific project reference.

Throws an exception if a project already has a specific project reference.

Throws an exception if project has a transitive reference to another project.

Throws an exception if a project does not have a specific metadata reference.

Throws an exception if a project already has a specific metadata reference.

Throws an exception if a project does not have a specific analyzer reference.

Throws an exception if a project already has a specific analyzer reference.

Throws an exception if a document is not part of the current solution.

Throws an exception if an additional document is not part of the current solution.

Throws an exception if a document is already part of the current solution.

Throws an exception if an additional document is already part of the current solution.

Gets the name to use for a project in an error message.

Gets the name to use for a document in an error message.

Gets the name to use for an additional document in an error message.

A class that responds to text buffer changes

True if this workspace supports manually opening and closing documents.

True if this workspace supports manually changing the ative context document of a text buffer.

The DocumentId of the current context document for the buffer that was previously attached to the given documentId, if any

Open the specified document.

Close the specified document.

Open the specified document.

Close the specified document.

Determines if the document is currently open in the host environment.

Gets a list of the currently opened documents.

Gets the ids for documents associated with a text container. Documents are normally associated with a text container when the documents are opened.

Gets the id for the document associated with the given text container in its current context. Documents are normally associated with a text container when the documents are opened.

The DocumentId of the current context document attached to the textContainer, if any.

This method is called during OnSolutionReload. Override this method if you want to manipulate the reloaded solution.

An event raised whenever the current solution is changed.

An event raised whenever the workspace or part of its solution model fails to access a file or other external resource.

An event that is fired when a documents is opened in the editor.

An event that is fired when a document is closed in the editor.

An event that is fired when the active context document associated with a buffer changes.

Gets the workspace associated with the specific text container.

Unregister a correspondence between a text container and a workspace.

Returns a for a given text container.

The current solution changed for an unspecified reason.

A solution was added to the workspace.

The current solution was removed from the workspace.

The current solution was cleared of all projects and documents.

The current solution was reloaded.

A project was added to the current solution.

A project was removed from the current solution.

A project in the current solution was changed.

A project in the current solution was reloaded.

A document was added to the current solution.

A document was removed from the current solution.

A document in the current solution was reloaded.

A document in the current solution was changed.

An additional document was added to the current solution.

An additional document was removed from the current solution.

An additional document in the current solution was reloaded.

An additional document in the current solution was changed.

Internal for testing purposes

Known workspace kinds

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

Returns the cached ResourceManager instance used by this class.

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

Looks up a localized string similar to Absolute path expected..

Looks up a localized string similar to Added:.

Looks up a localized string similar to Adding projects not supported in ApplyChanges..

Looks up a localized string similar to After:.

Looks up a localized string similar to {0} is already present..

Looks up a localized string similar to {0} is not present..

Looks up a localized string similar to Arrays with more than one dimension cannot be serialized..

Looks up a localized string similar to Before:.

Looks up a localized string similar to Cannot generate code for unsupported operator '{0}'.

Looks up a localized string similar to Cannot open project '{0}' because the file extension '{1}' is not associated with a language..

Looks up a localized string similar to Cannot open project '{0}' because the language '{1}' is not supported..

Looks up a localized string similar to Can't resolve analyzer reference: '{0}'..

Looks up a localized string similar to Can't resolve metadata reference: '{0}'..

Looks up a localized string similar to Cast is redundant..

Looks up a localized string similar to Adding project reference from '{0}' to '{1}' will cause a circular reference..

Looks up a localized string similar to Could not find location to generation symbol into..

Looks up a localized string similar to Cycle detected in extensions.

Looks up a localized string similar to Destination location was from a different tree..

Looks up a localized string similar to Supplied diagnostic cannot be null..

Looks up a localized string similar to At least one diagnostic must be supplied..

Looks up a localized string similar to The solution already contains the specified document..

Looks up a localized string similar to '{0}' is not open..

Looks up a localized string similar to {0} is still open..

Looks up a localized string similar to The project does not contain the specified document..

Looks up a localized string similar to The solution does not contain the specified document..

Looks up a localized string similar to The specified document is not a version of this document..

Looks up a localized string similar to An element with the same key but a different value already exists..

Looks up a localized string similar to Duplicate source file '{0}' in project '{1}'.

Looks up a localized string similar to An error occured while reading the specified configuration file: {0}.

Looks up a localized string similar to File was externally modified: {0}..

Looks up a localized string similar to Fix all occurrences.

Looks up a localized string similar to Fix all '{0}'.

Looks up a localized string similar to Fix all '{0}' in '{1}'.

Looks up a localized string similar to Fix all '{0}' in Solution.

Looks up a localized string similar to Invalid CodePage value: {0}.

Looks up a localized string similar to Destination type must be a {0}..

Looks up a localized string similar to Destination type must be a {0} or a {1}..

Looks up a localized string similar to Destination type must be a {0}, {1} or {2}..

Looks up a localized string similar to Documentation comment id must start with E, F, M, N, P or T.

Looks up a localized string similar to A language name cannot be specified for this option..

Looks up a localized string similar to A language name must be specified for this option..

Looks up a localized string similar to No location provided to add statements to..

Looks up a localized string similar to Destination location was not in source..

Looks up a localized string similar to Invalid number of parameters for binary operator..

Looks up a localized string similar to Invalid number of parameters for unary operator..

Looks up a localized string similar to Invalid project block, expected "=" after Project..

Looks up a localized string similar to Invalid project block, expected "," after project name..

Looks up a localized string similar to Invalid project block, expected "," after project path..

Looks up a localized string similar to Expected {0}..

Looks up a localized string similar to Invalid project file path: '{0}'.

Looks up a localized string similar to Invalid solution file path: '{0}'.

Looks up a localized string similar to This submission already references another submission project..

Looks up a localized string similar to Location must be null or from source..

Looks up a localized string similar to Metadata is already referenced..

Looks up a localized string similar to Metadata is not referenced..

Looks up a localized string similar to Expected end-of-file..

Looks up a localized string similar to Expected header: "{0}"..

Looks up a localized string similar to Expected {0} line..

Looks up a localized string similar to Name can be simplified..

Looks up a localized string similar to Node is of the wrong type..

Looks up a localized string similar to Specified path must be absolute..

Looks up a localized string similar to The solution already contains the specified project..

Looks up a localized string similar to '{0}' is already referenced..

Looks up a localized string similar to {0} still contains open documents..

Looks up a localized string similar to The project already references the target project..

Looks up a localized string similar to Project file not found: '{0}'.

Looks up a localized string similar to The solution does not contain the specified project..

Looks up a localized string similar to '{0}' is not referenced..

Looks up a localized string similar to '{0}' is already part of the workspace..

Looks up a localized string similar to '{0}' is not part of the workspace..

Looks up a localized string similar to The project already transitively references the target project..

Looks up a localized string similar to Removed:.

Looks up a localized string similar to Remove Unnecessary Imports/Usings..

Looks up a localized string similar to Removing projects not supported in ApplyChanges..

Looks up a localized string similar to Symbol "{0}" is not from source..

Looks up a localized string similar to Solution file not found: '{0}'.

Looks up a localized string similar to "{0}" must be a non-null and non-empty string..

Looks up a localized string similar to Temporary storage cannot be written more than once..

Looks up a localized string similar to Unknown identifier..

Looks up a localized string similar to Unmerged change from project '{0}'.

Looks up a localized string similar to Unrecognized language name..

Looks up a localized string similar to The language '{0}' is not supported..

Looks up a localized string similar to Value too large to be represented as a 30 bit unsigned integer..

Looks up a localized string similar to Workspace is not empty..

A concurrent, simplified HashSet.

The default concurrency level is 2. That means the collection can cope with up to two threads making simultaneous modifications without blocking. Note ConcurrentDictionary's default concurrency level is dynamic, scaling according to the number of processors.

Taken from ConcurrentDictionary.DEFAULT_CAPACITY

The backing dictionary. The values are never used; just the keys.

Construct a concurrent set with the default concurrency level.

Construct a concurrent set using the specified equality comparer.

The equality comparer for values in the set.

Obtain the number of elements in the set.

The number of elements in the set.

Determine whether the set is empty.

true if the set is empty; otherwise, false.

Determine whether the given value is in the set.

The value to test. true if the set contains the specified value; otherwise, false.

Attempts to add a value to the set.

The value to add. true if the value was added to the set. If the value already exists, this method returns false.

Attempts to remove a value from the set.

The value to remove. true if the value was removed successfully; otherwise false.

Clear the set

Obtain an enumerator that iterates through the elements in the set.

An enumerator for the set.

a simple Lisp-like immutable list. Good to use when lists are always accessed from the head.

Names of well-known XML attributes and elements.

This method is necessary to avoid an ambiguity between and . This method is necessary to avoid an ambiguity between and .

Convert a boxed primitive (generally of the backing type of an enum) into a ulong.

Implements a few file name utilities that are needed by the compiler. In general the compiler is not supposed to understand the format of the paths. In rare cases it needs to check if a string is a valid file name or change the extension (embedded resources, netmodules, output name). The APIs are intentionally limited to cover just these rare cases. Do not add more APIs.

Returns true if the string represents an unqualified file name. The name may contain any characters but directory and volume separators.

Path. True if is a simple file name, false if it is null or includes a directory specification.

Returns the offset in where the dot that starts an extension is, or -1 if the path doesn't have an extension.

Returns 0 for path ".foo". Returns -1 for path "foo.".

Returns an extension of the specified path string.

The same functionality as but doesn't throw an exception if there are invalid characters in the path.

Removes extension from path.

Returns "foo" for path "foo.". Returns "foo.." for path "foo...".

Returns path with the extenion changed to .

Equivalent of If is null, returns null. If path does not end with an extension, the new extension is appended to the path. If extension is null, equivalent to .

Returns the position in given path where the file name starts.

-1 if path is null.

Get file name from path.

Unlike doesn't check for invalid path characters.

Get directory name from path.

Unlike it doesn't check for invalid path characters, doesn't strip any trailing directory separators (TODO: tomat), doesn't recognize UNC structure \\computer-name\share\directory-name\file-name (TODO: tomat). Prefix of path that represents a directory.

Returns true if given path is absolute and starts with a drive specification ("C:\").

Get a prefix of given path which is the root of the path.

Root of an absolute path or null if the path isn't absolute or has invalid format (e.g. "\\"). It may or may not end with a directory separator (e.g. "C:\", "C:\foo", "\\machine\share", etc.) .

Calculates the length of root of an UNC path.

"\\server\share" is root of UNC path "\\server\share\dir1\dir2\file".

Combines an absolute path with a relative.

Absolute root path. Relative path. An absolute combined path, or null if is absolute (e.g. "C:\abc", "\\machine\share\abc"), relative to the current root (e.g. "\abc"), or relative to a drive directory (e.g. "C:abc\def").

Combine two paths, the first of which may be absolute.

First path: absolute, relative, or null. Second path: relative and non-null. null, if is null; a combined path, otherwise.

Determines whether an assembly reference is considered an assembly file path or an assembly name. used, for example, on values of /r and #r.

This is how VB Anonymous Types combine hash values for fields.

This is how VB Anonymous Types combine hash values for fields. PERF: Do not use with enum types because that involves multiple unnecessary boxing operations. Unfortunately, we can't constrain T to "non-enum", so we'll use a more restrictive constraint.

The offset bias value used in the FNV-1a algorithm See http://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function

The generative factor used in the FNV-1a algorithm See http://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function

Compute the FNV-1a hash of a sequence of bytes See http://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function

The sequence of bytes The FNV-1a hash of

Compute the FNV-1a hash of a sequence of bytes and determines if the byte sequence is valid ASCII and hence the hash code matches a char sequence encoding the same text. See http://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function

The sequence of bytes that are likely to be ASCII text. The length of the sequence. True if the sequence contains only characters in the ASCII range. The FNV-1a hash of

Compute the FNV-1a hash of a sequence of bytes See http://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function

The sequence of bytes The FNV-1a hash of

Compute the hashcode of a sub-string using FNV-1a See http://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function Note: FNV-1a was developed and tuned for 8-bit sequences. We're using it here for 16-bit Unicode chars on the understanding that the majority of chars will fit into 8-bits and, therefore, the algorithm will retain its desirable traits for generating hash codes.

The input string The start index of the first character to hash The number of characters, beginning with to hash The FNV-1a hash code of the substring beginning at and ending after characters.

Compute the hashcode of a sub-string using FNV-1a See http://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function

The input string The start index of the first character to hash The FNV-1a hash code of the substring beginning at and ending at the end of the string.

Compute the hashcode of a string using FNV-1a See http://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function

The input string The FNV-1a hash code of

Compute the hashcode of a string using FNV-1a See http://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function

The input string The FNV-1a hash code of

Compute the hashcode of a sub string using FNV-1a See http://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function

The input string as a char array The start index of the first character to hash The number of characters, beginning with to hash The FNV-1a hash code of the substring beginning at and ending after characters.

Compute the hashcode of a single character using the FNV-1a algorithm See http://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function Note: In general, this isn't any more useful than "char.GetHashCode". However, it may be needed if you need to generate the same hash code as a string or substring with just a single character.

The character to hash The FNV-1a hash code of the character.

Combine a string with an existing FNV-1a hash code See http://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function

The accumulated hash code The string to combine The result of combining with using the FNV-1a algorithm

Combine a char with an existing FNV-1a hash code See http://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function

The accumulated hash code The new character to combine The result of combining with using the FNV-1a algorithm

Null or empty.

"file"

".\file"

"..\file"

"\dir\file"

"C:dir\file"

"C:\file" or "\\machine" (UNC).

Compares objects based upon their reference identity.

Used to indicate places where we are hard-coding strings that will later need to be localized. This way, we can use a "Find All References" to find and fix these.

Checks if the given name is a sequence of valid CLR names separated by a dot.

Remove one set of leading and trailing double quote characters, if both are present.

Generic implementation of object pooling pattern with predefined pool size limit. The main purpose is that limited number of frequently used objects can be kept in the pool for further recycling. Notes: 1) it is not the goal to keep all returned objects. Pool is not meant for storage. If there is no space in the pool, extra returned objects will be dropped. 2) it is implied that if object was obtained from a pool, the caller will return it back in a relatively short time. Keeping checked out objects for long durations is ok, but reduces usefulness of pooling. Just new up your own. Not returning objects to the pool in not detrimental to the pool's work, but is a bad practice. Rationale: If there is no intent for reusing the object, do not use pool - just use "new".

Not using because this file is linked into the (debugger) Formatter, which does not have that type (since it compiles against .NET 2.0).

Produces an instance.

Search strategy is a simple linear probing which is chosen for it cache-friendliness. Note that Free will try to store recycled objects close to the start thus statistically reducing how far we will typically search.

Returns objects to the pool.

Removes an object from leak tracking. This is called when an object is returned to the pool. It may also be explicitly called if an object allocated from the pool is intentionally not being returned to the pool. This can be of use with pooled arrays if the consumer wants to return a larger array to the pool than was originally allocated.

A binder that used a predetermine list of types and reader functions.

A class that reads both primitive values and non-cyclical object graphs from a stream that was constructed using the ObjectWriter class.

Read a Boolean value from the stream. This value must have been written using .

Read a Byte value from the stream. This value must have been written using .

Read a Char value from the stream. This value must have been written using .

Read a Decimal value from the stream. This value must have been written using .

Read a Double value from the stream. This value must have been written using .

Read a Single value from the stream. This value must have been written using .

Read a Int32 value from the stream. This value must have been written using .

Read a Int64 value from the stream. This value must have been written using .

Read a SByte value from the stream. This value must have been written using .

Read a Int16 value from the stream. This value must have been written using .

Read a UInt32 value from the stream. This value must have been written using .

Read a UInt64 value from the stream. This value must have been written using .

Read a UInt16 value from the stream. This value must have been written using .

Read a DateTime value from the stream. This value must have been written using the .

Read a compressed 30-bit integer value from the stream. This value must have been written using .

Read a value from the stream. The value must have been written using ObjectWriter.WriteValue.

Read a String value from the stream. This value must have been written using ObjectWriter.WriteString.

A class that writes both primitive values and non-cyclical object graphs to a stream that may be later read back using the ObjectReader class.

Writes a Boolean value to the stream.

Writes a Byte value to the stream.

Writes a Char value to the stream.

Writes a Decimal value to the stream.

Writes a Double value to the stream.

Writes a Single value to the stream.

Writes a Int32 value to the stream.

Writes a Int64 value to the stream.

Writes a SByte value to the stream.

Writes a Int16 value to the stream.

Writes a UInt32 value to the stream.

Writes a UInt64 value to the stream.

Writes a UInt16 value to the stream.

Writes a DateTime value to the stream.

Writes a compressed 30 bit integer to the stream. (not 32 bit)

Writes a String value to the stream.

Writes any value (primitive or object graph) to the stream.

A binder that gathers type/reader mappings during object writing

Creates an event handler that holds onto the target weakly.

The target that is held weakly, and passed as an argument to the invoker. An action that will recieve the event arguments as well as the target instance. The invoker itself must not capture any state.

this is RAII object to automatically release pooled object when its owning pool

An AnnotationTable helps you attach your own annotation types/instances to syntax. It maintains a map between your instances and actual SyntaxAnnotation's used to annotate the nodes and offers an API that matches the true annotation API on SyntaxNode. The table controls the lifetime of when you can find and retrieve your annotations. You won't be able to find your annotations via HasAnnotations/GetAnnotations unless you use the same annotation table for these operations that you used for the WithAdditionalAnnotations operation. Your custom annotations are not serialized with the syntax tree, so they won't move across boundaries unless the same AnnotationTable is available on both ends. also, note that this table is not thread safe.

Represents a value that can be retrieved synchronously or asynchronously by many clients. The value will be computed on-demand the moment the first client asks for it. While being computed, more clients can request the value. As long as there are outstanding clients the underlying computation will proceed. If all outstanding clients cancel their request then the underlying value computation will be cancelled as well. Creators of an can specify whether the result of the computation is cached for future requests or not. Choosing to not cache means the computation functions are kept alive, whereas caching means the value (but not functions) are kept alive once complete.

The underlying function that starts an asynchronous computation of the resulting value. Null'ed out once we've computed the result and we've been asked to cache it. Otherwise, it is kept around in case the value needs to be computed again.

The underlying function that starts an synchronous computation of the resulting value. Null'ed out once we've computed the result and we've been asked to cache it, or if we didn't get any synchronous function given to us in the first place.

Whether or not we should keep the value around once we've computed it.

The Task that holds the cached result.

Mutex used to protect reading and writing to all mutable objects and fields. Traces indicate that there's negligible contention on this lock, hence we can save some memory by using a single lock for all AsyncLazy instances. Only trivial and non-reentrant work should be done while holding the lock.

The hash set of all currently outstanding asynchronous requests. Null if there are no requests, and will never be empty.

If an asynchronous request is active, the CancellationTokenSource that allows for cancelling the underlying computation.

Whether a computation is active or queued on any thread, whether synchronous or asynchronous.

Creates an AsyncLazy that always returns the value, analogous to .

Important: callers of this constructor should ensure that the compute function returns a task in a non-blocking fashion. i.e. the function should *not* synchronously compute a value and then return it using Task.FromResult. Instead, it should return an actual task that operates asynchronously. If this function synchronously computes a value then that will cause locks to be held in this type for excessive periods of time.

Creates an AsyncLazy that supports both asynchronous computation and inline synchronous computation.

A function called to start the asynchronous computation. This function should be cheap and non-blocking. A function to do the work synchronously, which is allowed to block. This function should not be implemented by a simple Wait on the asynchronous value. If that's all you are doing, just don't pass a synchronous function in the first place. Whether the result should be cached once the computation is complete.

Takes the lock for this object and if acquired validates the invariants of this class.

A semaphore that supports a WaitAsync() operation. Unlike SemaphoreSlim, WaitAsync does not have bugs where the semaphore can be acquired but WaitAsync returns cancelled.

Factory object that may be used for lazy initialization. Creates AsyncSemaphore instances with an initial count of 1.

Obtains the value for the specified key from a dictionary, or adds a new value to the dictionary where the key did not previously exist.

The type of key stored by the dictionary. The type of value stored by the dictionary. The type of argument supplied to the value factory. The variable or field to atomically update if the specified is not in the dictionary. The key for the value to retrieve or add. The function to execute to obtain the value to insert into the dictionary if the key is not found. The argument to pass to the value factory. The value obtained from the dictionary or if it was not present.

A queue that will only allow one instance of an object inside of it at a time. When an object is enqueued that is already in the list, it is removed from its location and placed at the end of the queue. These aspects make the queue useful for LRU caches. This class is not threadsafe. If you need it to be, wrap it within your own lock.

Adds this item (or moves it if it's already in the queue) to the end. If the item is not in the list, 'true' is returned, otherwise 'false'.

A lightweight mutual exclusion object which supports waiting with cancellation and prevents recursion (i.e. you may not call Wait if you already hold the lock)

The provides a lightweight mutual exclusion class that doesn't use Windows kernel synchronization primitives. The implementation is distilled from the workings of The basic idea is that we use a regular sync object (Monitor.Enter/Exit) to guard the setting of an 'owning thread' field. If, during the Wait, we find the lock is held by someone else then we register a cancellation callback and enter a "Monitor.Wait" loop. If the cancellation callback fires, then it "pulses" all the waiters to wake them up and check for cancellation. Waiters are also "pulsed" when leaving the lock. All public members of are thread-safe and may be used concurrently from multiple threads.

A synchronization object to protect access to the field and to be pulsed when is called and during cancellation.

The of the thread that holds the lock. Zero if no thread is holding the lock.

Constructor.

If false (the default), then the class allocates an internal object to be used as a sync lock. If true, then the sync lock object will be the NonReentrantLock instance itself. This saves an allocation but a client may not safely further use this instance in a call to Monitor.Enter/Exit or in a "lock" statement.

Shared factory for use in lazy initialization.

Blocks the current thread until it can enter the , while observing a .

Recursive locking is not supported. i.e. A thread may not call Wait successfully twice without an intervening . The token to observe. was canceled. The caller already holds the lock

Exit the mutual exclusion.

The calling thread must currently hold the lock. The lock is not currently held by the calling thread.

Determine if the lock is currently held by the calling thread.

True if the lock is currently held by the calling thread.

Throw an exception if the lock is not held by the calling thread.

The lock is not currently held by the calling thread.

Checks if the lock is currently held.

Checks if the lock is currently held by the calling thread.

Take ownership of the lock (by the calling thread). The lock may not already be held by any other code.

Release ownership of the lock. The lock must already be held by the calling thread.

Action object passed to a cancellation token registration.

Callback executed when a cancellation token is canceled during a Wait.

The syncLock that protects a instance.

Since we want to avoid boxing the return from , this type must be public.

Equivalent to Debug.Assert. DevDiv 867813 covers removing this completely at a future date

Throws a non-accessible exception if the provided value is null. This method executes in all builds

Throws a non-accessible exception if the provided value is false. This method executes in all builds

Throws a non-accessible exception if the provided value is true. This method executes in all builds.

Ensure that the given target value is initialized (not null) in a thread-safe manner.

The type of the target value. Must be a reference type. The target to initialize. A factory delegate to create a new instance of the target value. Note that this delegate may be called more than once by multiple threads, but only one of those values will successfully be written to the target. The target value.

Ensure that the given target value is initialized (not null) in a thread-safe manner.

The type of the target value. Must be a reference type. The target to initialize. The type of the argument passed to the value factory. A factory delegate to create a new instance of the target value. Note that this delegate may be called more than once by multiple threads, but only one of those values will successfully be written to the target. An argument passed to the value factory. The target value.

Shared object pool for roslyn Use this shared pool if only concern is reducing object allocations. if perf of an object pool itself is also a concern, use ObjectPool directly. For example, if you want to create a million of small objects within a second, use the ObjectPool directly. it should have much less overhead than using this.

pool that uses default constructor with 100 elements pooled

pool that uses default constructor with 20 elements pooled

pool that uses string as key with StringComparer.OrdinalIgnoreCase as key comparer

pool that uses string as element with StringComparer.OrdinalIgnoreCase as element comparer

pool that uses string as element with StringComparer.Ordinal as element comparer

Used to reduce the # of temporary byte[]s created to satisfy serialization and other I/O requests

pooled memory : 4K * 512 = 4MB

Helpers to create temporary streams backed by pooled memory

schedules task to run in sequence.

An object to synchronize reads/writes of all mutable fields of this class.

Stores the "path" from the root of a tree to a node, allowing the node to be recovered in a later snapshot of the tree, under certain circumstances. The implementation stores the child indices to represent the path, so any edit which affects the child indices could render this object unable to recover its node. NOTE: One thing C# IDE has done in the past to do a better job of this is to store the fully qualified name of the member to at least be able to descend into the same member. We could apply the same sort of logic here.

Attempts to recover the node at this path in the provided tree. If the node is found then 'true' is returned, otherwise the result is 'false' and 'node' will be null.

You should not call this method.. Use WaitAndGetResult instead.

This value source keeps a strong reference to a value.

A class that abstracts the accessing of a value

A that keeps a weak reference to a value.

An immutable unordered hash map implementation.

The type of the key. The type of the value.

The root node of the tree that stores this map.

The comparer used to sort keys in this map.

The comparer used to detect equivalent values in this map.

Initializes a new instance of the class.

The root. The comparer. The value comparer.

Initializes a new instance of the class.

The comparer. The value comparer.

Gets an empty map with default equality comparers.

See the interface.

Applies a given set of key=value pairs to an immutable dictionary, replacing any conflicting keys in the resulting dictionary.

The key=value pairs to set on the map. Any keys that conflict with existing keys will overwrite the previous values. An immutable dictionary.

See the interface.

Returns a hash map that uses the specified key and value comparers and has the same contents as this map.

The key comparer. A value of null results in using the default equality comparer for the type. The value comparer. A value of null results in using the default equality comparer for the type. The hash map with the new comparers. In the event that a change in the key equality comparer results in a key collision, an exception is thrown.

Returns a hash map that uses the specified key comparer and current value comparer and has the same contents as this map.

The key comparer. A value of null results in using the default equality comparer for the type. The hash map with the new comparers. In the event that a change in the key equality comparer results in a key collision, an exception is thrown.

Determines whether the ImmutableSortedMap<TKey,TValue> contains an element with the specified value.

The value to locate in the ImmutableSortedMap<TKey,TValue>. The value can be null for reference types. true if the ImmutableSortedMap<TKey,TValue> contains an element with the specified value; otherwise, false.

Gets the number of elements in this collection.

Gets a value indicating whether this instance is empty.

true if this instance is empty; otherwise, false.

Gets the keys in the map.

Gets the values in the map.

Gets the with the specified key.

Determines whether the specified key contains key.

The key. true if the specified key contains key; otherwise, false.

Determines whether this map contains the specified key-value pair.

The key value pair. true if this map contains the key-value pair; otherwise, false.

See the interface.

Returns an enumerator that iterates through the collection.

A that can be used to iterate through the collection.

Returns a that represents this instance.

A that represents this instance.

Exchanges a key for the actual key instance found in this map.

The key to search for. Receives the equal key found in the map. A value indicating whether an equal and existing key was found in the map.

Attempts to discover an instance beneath some enumerable sequence if one exists.

The sequence that may have come from an immutable map. Receives the concrete typed value if one can be found. true if the cast was successful; false otherwise.

Bulk adds entries to the map.

The entries to add. true to allow the sequence to include duplicate keys and let the last one win; false to throw on collisions. true when being called from ToHashMap to avoid StackOverflow.

The hash for this bucket.

Initializes a new instance of the class.

The hash.

Initializes a new instance of the class.

The key. The value. The hashcode.

Initializes a new instance of the class.

The buckets.

Initializes a new instance of the class.

The hash roll. The used. The buckets. The count.

Initializes a new instance of the class.

The suggested hash roll. The bucket1. The bucket2.

A simple view of the immutable collection that the debugger can show to the developer.

The collection to be enumerated.

The simple view of the collection.

Initializes a new instance of the class.

The collection to display in the debugger

Gets a simple debugger-viewable collection.