Microsoft.CodeAnalysis

Represents a non source code file.

Path to the file.

Returns a with the contents of this file, or null if there were errors reading the file.

Errors encountered when trying to read the additional file. Always empty if has not been called.

If is set, then will be null. The only arity in that case will be encoded in the symbol.

This is base class for a bag used to accumulate information while binding is performed. Including diagnostic messages and dependencies in the form of "used" assemblies.

An information that should be reported at a call site of a symbol.

Diagnostic info that should be reported at the use site of the symbol, or null if there is none.

When not-null, this is primary dependency of the use-site, usually the assembly defining the used symbol. Never a core library. Usually it is not included into the . Null if is an error.

The set of other assemblies the use site will depend upon, excluding a core library. Empty if is an error.

A helper used to combine information from multiple s related to the same use site.

A helper used to efficiently cache in the symbol.

Either - null (meaning no diagnostic info and dependencies), or - a , or - dependencies as a , or - a tuple of a and a .

Atomically initializes the cache with the given value if it is currently fully default. This will not initialize .

Diagnostic info that should be reported at the use site of the symbol, or null if there is none.

The set of assemblies the use site will depend upon, excluding assembly for core library. Empty or null if is an error.

Case-insensitive operations (mostly comparison) on unicode strings.

ToLower implements the Unicode lowercase mapping as described in ftp://ftp.unicode.org/Public/UNIDATA/UnicodeData.txt. VB uses these mappings for case-insensitive comparison.

If is upper case, then this returns its Unicode lower case equivalent. Otherwise, is returned unmodified.

This class seeks to perform the lowercase Unicode case mapping.

Returns a StringComparer that compares strings according to Unicode rules for case-insensitive identifier comparison (lower-case mapping).

These are also the rules used for VB identifier comparison.

Returns a StringComparer that compares strings according to Unicode rules for case-insensitive identifier comparison (lower-case mapping).

These are also the rules used for VB identifier comparison.

Determines if two strings are equal according to Unicode rules for case-insensitive identifier comparison (lower-case mapping).

First identifier to compare Second identifier to compare true if the identifiers should be considered the same. These are also the rules used for VB identifier comparison.

Determines if two strings are equal according to Unicode rules for case-insensitive identifier comparison (lower-case mapping).

First identifier to compare Second identifier to compare true if the identifiers should be considered the same. These are also the rules used for VB identifier comparison.

Determines if the string 'value' end with string 'possibleEnd'.

Determines if the string 'value' starts with string 'possibleStart'.

Compares two strings according to the Unicode rules for case-insensitive identifier comparison (lower-case mapping).

First identifier to compare Second identifier to compare -1 if < , 1 if > , 0 if they are equal. These are also the rules used for VB identifier comparison.

Compares two strings according to the Unicode rules for case-insensitive identifier comparison (lower-case mapping).

First identifier to compare Second identifier to compare -1 if < , 1 if > , 0 if they are equal. These are also the rules used for VB identifier comparison.

Gets a case-insensitive hash code for Unicode identifiers.

identifier to get the hash code for The hash code for the given identifier These are also the rules used for VB identifier comparison.

Convert a string to lower case per Unicode

In-place convert string in StringBuilder to lower case per Unicode rules

Constructs and caches already created pseudo-methods. Every compiled module is supposed to have one of this, created lazily (multidimensional arrays are not common).

Acquires an array constructor for a given array type

Acquires an element getter method for a given array type

Acquires an element setter method for a given array type

Acquires an element referencer method for a given array type

Maps {array type, method kind} tuples to implementing pseudo-methods.

lazily fetches or creates a new array method.

"newobj ArrayConstructor" is equivalent of "newarr ElementType" when working with multidimensional arrays

"call ArrayGet" is equivalent of "ldelem ElementType" when working with multidimensional arrays

"call ArrayAddress" is equivalent of "ldelema ElementType" when working with multidimensional arrays

"call ArraySet" is equivalent of "stelem ElementType" when working with multidimensional arrays

Represents a parameter in an array pseudo-method. NOTE: It appears that only number of indices is used for verification, types just have to be Int32. Even though actual arguments can be native ints.

Represents the "value" parameter of the Set pseudo-method. NOTE: unlike index parameters, type of the value parameter must match the actual element type.

Base of all array methods. They have a lot in common.

Identifies a specific await within a set of awaits generated for a syntax node. If multiple await expressions are produced for the same syntax node EnC needs to know how they map to specific async calls. For example, `await foreach` generates two awaits -- one for MoveNextAsync ( is 0) and the other for DisposeAsync ( is 1).

Block is not reachable or reachability analysis has not been performed.

Block can be reached either falling through from previous block or from branch.

Block is reachable from try or catch but finally prevents falling through.

Returns true if this block has a branch label and is not a "nop" branch.

Instructions that are not branches.

The block contains only the final branch or nothing at all

Updates position of the current block to account for shorter sizes of previous blocks.

If possible, changes the branch code of the current block to the short version and updates the delta correspondingly.

Position delta created by previous block size reductions.

replaces branches with more compact code if possible. * same branch as in the next ===> nop * branch to the next block ===> nop * branch to ret block ===> ret * cond branch over uncond branch ===> flip condition, skip next block * cond branch to equivalent ===> pop args + nop

Blocks are identical if: 1) have same regular instructions 2) lead to unconditional control transfer (no fall through) 3) branch with the same instruction to the same label

Returns reversed branch operation for the current block. If no reverse opcode can be obtained Nop is returned.

Abstract Execution state. If we know something interesting about IL stream we put it here.

Eval stack's high watermark.

Current evaluation stack depth.

Record effects of that currently emitted instruction on the eval stack.

In some cases we have to get a final IL offset during emit phase, for example for proper emitting sequence points. The problem is that before the builder is realized we don't know the actual IL offset, but only {block/offset-in-the-block} pair. Thus, whenever we need to mark some IL position we allocate a new marker id, store it in and reference this IL marker in the entity requiring the IL offset. IL markers will be 'materialized' when the builder is realized; the resulting offsets will be put into array. Note that only markers from reachable blocks are materialized, the rest will have offset -1.

Realizes method body. No more data can be added to the builder after this call.

Gets all scopes that contain variables.

IL opcodes emitted by this builder. This includes branch instructions that end blocks except if they are fall-through NOPs. This count allows compilers to see if emitting a particular statement/expression actually produced any instructions. Example: a label will not result in any code so when emitting debugging information an extra NOP may be needed if we want to decorate the label with sequence point.

Marks blocks that are reachable.

Marks blocks that are recursively reachable from the given block.

If a label points to a block that does nothing other than passing to block X, replaces target label's block with block X.

Drops blocks that are not reachable Returns true if any blocks were dropped

Marks all blocks unreachable.

Rewrite any block marked as BlockedByFinally as an "infinite loop".

Matches the code generated by the native compiler in ILGENREC::AdjustBlockedLeaveTargets.

Returns true if the block has the signature of the special labeled block that follows a complete try/catch or try/finally.

Returns true if any branches were optimized (that does not include shortening) We need this because optimizing a branch may result in unreachable code that needs to be eliminated. === Example: x = 1; if (blah) { global = 1; } else { throw null; } return x; === rewrites into push 1; if (blah) { global = 1; ret; } else { throw null; } // this ret unreachable now! // even worse - empty stack is assumed thus the ret is illegal. ret;

Define a sequence point with the given syntax tree and span within it.

Defines a hidden sequence point. The effect of this is that debugger will not associate following code with any source (until it sees a lexically following sequence point). This is used for synthetic code that is reachable through labels. If such code is not separated from previous sequence point by the means of a hidden sequence point It looks as a part of the statement that previous sequence point specifies. As a result, when user steps through the code and goes through a jump to such label, it will appear as if the jump landed at the beginning of the previous statement. NOTE: Also inserted as the first statement of a method that would not otherwise have a leading sequence point so that step-into will find the method body.

Define a hidden sequence point at the first statement of the method so that step-into will find the method body.

This is called when starting emitting a method for which there is some source. It is done in case the first sequence point is a hidden point. Even though hidden points do not have syntax, they need to associate with some document.

Marks the end of filter condition and start of the actual filter handler.

Puts local variable into current scope.

Puts local constant into current scope.

Mark current IL position with a label

Primary method for emitting string switch jump table

switch case labels fall through label for the jump table Local holding the value to switch on. This value has already been loaded onto the execution stack. Local holding the hash value of the key for emitting hash table switch. Hash value has already been computed and loaded into keyHash. This parameter is null if emitting non hash table switch. Delegate to emit string compare call and conditional branch based on the compare result. Delegate to compute string hash consistent with value of keyHash.

Primary method for emitting integer switch jump table.

switch case labels fall through label for the jump table. Local or parameter holding the value to switch on. This value has already been loaded onto the execution stack. Primitive type code of switch key.

Finishes filter condition (and starts actual handler portion of the handler). Returns the last block of the condition.

Generates code that creates an instance of multidimensional array

Generates code that loads an element of a multidimensional array

Generates code that loads an address of an element of a multidimensional array.

Generates code that stores an element of a multidimensional array.

Contains information about a label.

Sometimes we need to know if a label is targeted by conditional branches. For example optimizer can do optimizations of branches into outer try scopes only if they are unconditional (because there are no conditional Leave opcodes)

Used when we see a branch, but label is not yet marked.

Used when label is marked to the code.

Gets all scopes that contain variables.

Returns an ExceptionHandlerRegion for each exception handler clause beneath the root scope. Each ExceptionHandlerRegion indicates the type of clause (catch or finally) and the bounds of the try block and clause block.

Base class for IL scopes where a scope contains IL blocks and other nested scopes. A scope may represent a scope for variable declarations, an exception handler clause, or an entire exception handler (multiple clauses).

Recursively calculates the start and end of the given scope. Only scopes with locals are actually dumped to the list.

Free any basic blocks owned by this scope or sub-scopes.

Class that collects content of the scope (blocks, nested scopes, variables etc). There is one for every opened scope.

A scope for a single try, catch, or finally clause. If the clause is a catch clause, ExceptionType will be set.

A scope for an entire exception handler (a try block with either several catches or a finally block). Unlike other scopes, this scope contains nested scopes only, no IL blocks (although nested ExceptionHandlerScopes for the clauses will contain IL blocks).

Compares scopes by their start (ascending) and then size (descending).

Debug information maintained for each closure.

The information is emitted to PDB in Custom Debug Information record for a method containing the closure.

Debug information maintained for each closure.

The information is emitted to PDB in Custom Debug Information record for a method containing the closure.

Unique identification of an emitted entity (method, lambda, closure) used for debugging purposes (EnC).

When used for a synthesized method the ordinal and generation numbers are included its name. For user defined methods the ordinal is included in Custom Debug Information record attached to the method.

The index of the method in member list of the containing type, or if undefined.

The EnC generation the method was defined in (0 is the baseline build).

These opcodes represent control transfer. They should not appear inside basic blocks.

Opcodes that represents a branch to a label.

Handles storage of items referenced via tokens in metadata. When items are stored they are uniquely "associated" with fake tokens, which are basically sequential numbers. IL gen will use these fake tokens during codegen and later, when actual values are known, the method bodies will be patched. To support these two scenarios we need two maps - Item-->uint, and uint-->Item. (The second is really just a list).

Gets a field that may be used to lazily cache an array created to store the specified data.

This is used to cache an array created with the data passed to .

Gets the or corresponding to this token.

Debug information maintained for each lambda.

The information is emitted to PDB in Custom Debug Information record for a method containing the lambda.

The syntax offset of the syntax node declaring the lambda (lambda expression) or its body (lambda in a query).

The ordinal of the closure frame the lambda or local function belongs to, or if the lambda is static, or if the lambda is closed over "this" pointer only.

We need a CCI representation for local constants because they are emitted as locals in PDB scopes to improve the debugging experience (see LocalScopeProvider.GetConstantsInScope).

Id that associates an emitted user-defined or long-lived synthesized local variable with a syntax node that defined it. If a syntax node defines multiple variables it provides information necessary to identify which one of these variables is it.

We calculate a "syntax offset" for each user-defined and long-lived synthesized variable. Every such variable symbol has to be associated with a syntax node (its declarator). In usual cases this is the textual distance of the declarator from the start of the method body. It gets a bit complicated when the containing method body is not contiguous (constructors). If the variable is in the body of the constructor the definition of syntax offset is the same. If the variable is defined in a constructor initializer or in a member initializer (this is only possible when declaration expressions or closures in primary constructors are involved) then the distance is a negative sum of the widths of all the initializers that succeed the declarator of the variable in the emitted constructor body plus the relative offset of the declarator from the start of the containing initializer.

If a single node is a declarator for multiple variables of the same synthesized kind (it can only happen for synthesized variables) we calculate additional number "ordinal" for such variable. We assign the ordinals to the synthesized variables with the same kind and syntax offset in the order as they appear in the lowered bound tree. It is important that a valid EnC edit can't change the ordinal of a synthesized variable. If it could it would need to be assigned a different kind or associated with a different declarator node.

Creates a new LocalDefinition.

Local symbol, used by edit and continue only, null otherwise. Name associated with the slot. Type associated with the slot. Slot position in the signature. Local kind. Local id. Value to emit in the attributes field in the PDB. Specifies whether slot type should have pinned modifier and whether slot should have byref constraint. The synthesized dynamic attributes of the local. Tuple element names of the local.

At this level there are two kinds of local variables: Locals - have identities by which consuming code refers to them. Typical use is a local variable or a compiler generated temp that can be accessed in multiple operations. Any object can be used as identity. Reference equality is used. Temps - do not have identity. They are borrowed and returned to the free list. Typical use is a scratch temporary or spilling storage.

Structure that represents a local signature (as in ECMA-335, Partition I, §8.6.1.3 Local signatures).

Retrieve a local slot by its symbol.

Release a local slot by its symbol. Slot is not associated with symbol after this.

Gets a local slot.

Frees a local slot.

An expression that creates an array instance in metadata. Only for use in custom attributes.

An expression that represents a (name, value) pair and that is typically used in method calls, custom attributes and object initializers.

The name of the parameter or property or field that corresponds to the argument.

The value of the argument.

True if the named argument provides the value of a field.

An expression that results in a System.Type instance.

The type that will be represented by the System.Type instance.

Holds on to the method body data.

This is a list of the using directives that were in scope for this method body.

Ordered by .

True if there's a stackalloc somewhere in the method.

This class represents the PermissionSetAttribute specified in source which needs fixup during codegen.

PermissionSetAttribute needs fixup when it contains an assignment to the 'File' property as a single named attribute argument. Fixup performed is ported from SecurityAttributes::FixUpPermissionSetAttribute at ndp\clr\src\vm\securityattributes.cpp. It involves following steps: 1) Verifying that the specified file name resolves to a valid path: This is done during binding. 2) Reading the contents of the file into a byte array. 3) Convert each byte in the file content into two bytes containing hexadecimal characters (see method ). 4) Replacing the 'File = fileName' named argument with 'Hex = hexFileContent' argument, where hexFileContent is the converted output from step 3) above.

Zero or more positional arguments for the attribute constructor.

A reference to the constructor that will be used to instantiate this custom attribute during execution (if the attribute is inspected via Reflection).

Zero or more named arguments that specify values for fields and properties of the attribute.

The number of positional arguments.

The number of named arguments.

The type of the attribute. For example System.AttributeUsageAttribute.

Exception class to enable generating ERR_PermissionSetAttributeFileReadError while reading the file for PermissionSetAttribute fixup.

TypeDefinition that represents <PrivateImplementationDetails> class. The main purpose of this class so far is to contain mapped fields and their types.

Gets a field that can be used to cache an array allocated to store data from a corresponding call.

The data that will be used to initialize the field. The type of the field, e.g. int[]. The emit context to use with the array type to extract its element type. The field to use to cache an array for this data and alignment.

Gets a field that can be used to to store data directly in an RVA field.

The data for the field. The alignment value is the necessary alignment for addresses for the underlying element type of the array. The data is stored by using a type whose size is equal to the total size of the blob. If a built-in system type has an appropriate size and .pack, it can be used. Otherwise, a type is generated of the same size as the data, and that type needs its .pack set to the alignment required for the underlying data. While that .pack value isn't required by anything else in the compiler (the compiler always aligns RVA fields at 8-byte boundaries, which accomodates any element type that's relevant), it is necessary for IL rewriters. Such rewriters also need to ensure an appropriate alignment is maintained for the RVA field, and while they could also simplify by choosing a worst-case alignment as does the compiler, they may instead use the .pack value as the alignment to use for that field, since it's an opaque blob with no other indication as to what kind of data is stored and what alignment might be required. The field. This may have been newly created or may be an existing field previously created for the same data and alignment.

Simple struct type with explicit size and no members.

Synthesized by instrumentation.

Definition of a simple field mapped to a metadata block

Definition of a field for storing an array caching the data from a metadata block or array of constants.

Just a default implementation of a type definition.

Represents a sequence point before translation by #line/ExternalSource directives.

Some features of the compiler (such as anonymous types, pay-as-you-go, NoPIA, ...) rely on all referenced symbols to go through translate mechanism. Because by default symbol translator does not translate some of indirectly referenced symbols, such as type argument, we have to force translation here This class provides unified implementation for this functionality.

Scope of user-defined variable hoisted to state machine.

Maintains a list of sequence points in a space efficient way. Most of the time sequence points occur in the same syntax tree, so optimize for that case. Store a sequence point as an offset, and position in a syntax tree, then translate to CCI format only on demand. Use a ArrayBuilder{RawSequencePoint} to create.

Create a SequencePointList with the raw sequence points from an ArrayBuilder. A linked list of instances for each syntax tree is created (almost always of length one).

Get all the sequence points, possibly mapping them using #line/ExternalSource directives, and mapping file names to debug documents with the given mapping function.

Function that maps file paths to CCI debug documents where sequence points should be deposited

Represents the combination of an IL offset and a source text span.

A local whose type is represented by a metadata signature instead of a type symbol.

Used when emitting a new version of a method during EnC for variables that are no longer used. This temp is not interesting to the expression compiler. However, it may be replaced by an interesting local in a later stage.

Debug information maintained for each state machine. Facilitates mapping of state machine states from a compilation to the previous one (or to a metadata baseline) during EnC.

The number of the first state that has not been used in any of the previous versions of the state machine, or null if we are not generating EnC delta. For 1st generation EnC delta, this is calculated by examining the stored in the baseline metadata. For subsequent generations, the number is updated to account for newly generated states in that generation.

The number of the first state that has not been used in any of the previous versions of the state machine, or null if we are not generating EnC delta, or the state machine has no decreasing states. For 1st generation EnC delta, this is calculated by examining the stored in the baseline metadata. For subsequent generations, the number is updated to account for newly generated states in that generation.

Class for emitting the switch jump table for switch statements with integral governing type

Switch key for the jump table

Primitive type of the switch key

Fall through label for the jump table

Integral case labels sorted and indexed by their ConstantValue

Degenerate buckets here are buckets with contiguous range of constants leading to the same label. Like: case 0: case 1: case 2: case 3: DoOneThing(); break; case 4: case 5: case 6: case 7: DoAnotherThing(); break; NOTE: A trivial bucket with only one case constant is by definition degenerate.

Try to merge with the nextBucket. If merge results in a better bucket than two original ones, merge and return true. Else don't merge and return false.

Switch key for the jump table

Switch case labels

Fall through label for the jump table

Delegate to emit string compare call and conditional branch based on the compare result.

Key to compare Case constant to compare the key against Target label to branch to if key = stringConstant

Delegate to compute string hash code. This piece is language-specific because VB treats "" and null as equal while C# does not.

Delegate to emit string compare call

Delegate to emit string hash

Local storing the key hash value, used for emitting hash table based string switch.

Dispenser of unique ordinals for synthesized variable names that have the same kind and syntax offset.

Handles storage of items referenced via tokens in metadata (strings or Symbols). When items are stored they are uniquely "associated" with fake token, which is basically a sequential number. IL gen will use these fake tokens during codegen and later, when actual token values are known the method bodies will be patched. To support these two scenarios we need two maps - Item-->uint, and uint-->Item. (the second is really just a list). This map supports tokens of type and .

Returns an index of a slot that stores specified hoisted local variable in the previous generation.

Number of slots reserved for hoisted local variables.

Some of the slots might not be used anymore (a variable might have been deleted or its type changed). Still, new hoisted variables are assigned slots starting with .

Returns true and an index of a slot that stores an awaiter of a specified type in the previous generation, if any.

Number of slots reserved for awaiters.

Some of the slots might not be used anymore (the type of an awaiter might have changed). Still, new awaiters are assigned slots starting with .

The id of the method, or null if the method wasn't assigned one.

Finds a closure in the previous generation that corresponds to the specified syntax.

Syntax of the closure scope. Id of the parent closure. Names of variables hoisted into the closure, or default if the closure is a class. Id of the closure assigned in the generation that defined the closure. Not-null if the previous closure is found, but is incompatible with the shape of the closure in the current source. The previous closure can't be reused (a new one needs to be emitted) and IL bodies of lambdas of the previous closure are updated to throw an exception. The exception message is specified in . See LambdaFrame.AssertIsLambdaScopeSyntax for kinds of syntax nodes that represent closures.

Finds a lambda in the previous generation that corresponds to the specified syntax.

Syntax of the lambda or its body. True if is a lambda body syntax, false if it is a lambda syntax. The ordinal of the closure the lambda is emitted to. Id of the lambda assigned in the generation that defined the lambda. Not-null if the previous lambda is found, but is incompatible with the shape of the lambda in the current source. The previous lambda can't be reused (a new one needs to be emitted) and the previous lambda IL body is updated to throw an exception. The exception message is specified in .

State number to be used for next state of the state machine, or if none of the previous versions of the method was a state machine with an increasing state

True if the state number increases with progress, false if it decreases (e.g. states for iterator try-finally blocks, or iterator states of async iterators).

For a given node associated with entering a state of a state machine in the new compilation, returns the ordinal of the corresponding state in the previous version of the state machine.

Await expression, await foreach statement, yield return statement, or try block syntax node. True if there is a corresponding node in the previous code version that matches the given .

First state of an async iterator state machine that is used to resume the machine after yield return. Initial state is not used to resume state machine that yielded. State numbers decrease as the iterator makes progress.

Initial iterator state of an async iterator. Distinct from so that DisposeAsync can throw in latter case.

First state of an iterator state machine. State numbers decrease for subsequent finalize states.

First state in async state machine that is used to resume the machine after await. State numbers increase as the async computation makes progress.

Initial iterator state of an iterator.

First state in iterator state machine that is used to resume the machine after yield return. Initial state is not used to resume state machine that yielded. State numbers increase as the iterator makes progress.

Maps an array builder to immutable array.

The array to map The mapping delegate If the items's length is 0, this will return an empty immutable array

Maps an array builder to immutable array.

The sequence to map The mapping delegate The extra input used by mapping delegate If the items's length is 0, this will return an empty immutable array.

Maps an array builder to immutable array.

The sequence to map The mapping delegate The extra input used by mapping delegate If the items's length is 0, this will return an empty immutable array.

Realizes the OneOrMany and disposes the builder in one operation.

Create BitArray with at least the specified number of bits.

return a bit array with all bits set from index 0 through bitCount-1

Make a copy of a bit array.

Invert all the bits in the vector.

Is the given bit array null?

Modify this bit vector by bitwise AND-ing each element with the other bit vector. For the purposes of the intersection, any bits beyond the current length will be treated as zeroes. Return true if any changes were made to the bits of this bit vector.

Modify this bit vector by '|'ing each element with the other bit vector.

True if any bits were set as a result of the union.

The CachingLookup class provides a convenient representation of an ILookup that is based upon a potentially slow lookup, and caches lookup results so that subsequent lookups are fast. Internally a ConcurrentDictionary is used to cache lookup results. The client provides two delegates to perform lookups: One that maps a key to a IEnumerable of values, and one that provides all keys. The client must provide an IEqualityComparer used for comparing keys. Failed lookups are cached, but that has the disadvantage that every different failed lookup will consume a small amount of extra memory. However, that memory can be reclaimed by forcing a full population of the cache. Thread safe.

Create a CachingLookup.

A function that takes a key, and returns an IEnumerable of values that correspond to that key. If no values correspond, the function may either return null or an empty IEnumerable. A function that returns an IEnumerable of all keys that have associated values. A IEqualityComparer used to compare keys.

Does this key have one or more associated values?

Get the values associated with a key.

Key to look up. All values associated with key. Returns an empty IEnumerable if no values are associated. Never returns null.

Get the number of distinct keys. Forces a full population of the cache.

Enumerate all the keys. Forces a full population of the cache.

Add the values from all keys to a flat array. Forces a full population of the cache.

Create an instance of the concurrent dictionary.

The concurrent dictionary

Create a dictionary instance suitable for use as the fully populated map.

A new, empty dictionary, suitable for use as the fully populated map.

Use the underlying (possibly slow) functions to get the values associated with a key.

Add a new value with the given key to the given concurrent map.

The concurrent map to augment. The key of the new entry. The added entry. If there was a race, and another thread beat this one, then this returns the previously added entry.

Determines if the given map is fully populated.

The map to test. true if the map is fully populated.

Create the fully populated map from an existing map and the key generator.

The existing map which may be null or a ConcurrentDictionary.

Fully populate the underlying dictionary. Once this returns, the dictionary is guaranteed to have every key in it.

A MultiDictionary that allows only adding, and preserves the order of values added to the dictionary. Thread-safe for reading, but not for adding.

Always uses the default comparer.

Add a value to the dictionary.

Get all values associated with K, in the order they were added. Returns empty read-only array if no values were present.

Get a collection of all the keys.

Each value is either a single V or an . Never null.

A set of ints that is small, thread-safe and lock free. Several assumptions have been made that allow it to be small and fast: 1. Deletes never happen. 2. The size is small. In dogfooding experiments, 89% had 4 or fewer elements and 98% had 8 or fewer elements. The largest size was 17. 3. As a result of assumption 2, linear look-up is good enough. 4. One value, in this case int.MinValue, is used as a sentinel and may never appear in the set.

Determine if the given integer appears in the set.

The value to look up. true if appears in the set. false otherwise.

Insert the given value into the set.

The value to insert true if was added. false if it was already present.

If the given slot is unoccupied, then try to replace it with a new value.

The slot to examine. The new value to insert if the slot is unoccupied. An out param indicating whether the slot was successfully updated. true if the value in the slot either now contains, or already contained . false otherwise.

Provides methods for creating a segmented dictionary that is immutable; meaning it cannot be changed once it is created.

Represents a segmented dictionary that is immutable; meaning it cannot be changed once it is created.

There are different scenarios best for and others best for . In general, is applicable in scenarios most like the scenarios where is applicable, and is applicable in scenarios most like the scenarios where is applicable. The following table summarizes the performance characteristics of : Operation Complexity Complexity Comments Item O(1) O(log n) Directly index into the underlying segmented dictionary Add() O(n) O(log n) Requires creating a new segmented dictionary This type is backed by segmented arrays to avoid using the Large Object Heap without impacting algorithmic complexity. The type of the keys in the dictionary. The type of the values in the dictionary. This type has a documented contract of being exactly one reference-type field in size. Our own class depends on it, as well as others externally. IMPORTANT NOTICE FOR MAINTAINERS AND REVIEWERS: This type should be thread-safe. As a struct, it cannot protect its own fields from being changed from one thread while its members are executing on other threads because structs can change in place simply by reassigning the field containing this struct. Therefore it is extremely important that ⚠⚠ Every member should only dereference this ONCE ⚠⚠. If a member needs to reference the field, that counts as a dereference of this. Calling other instance members (properties or methods) also counts as dereferencing this. Any member that needs to use this more than once must instead assign this to a local variable and use that for the rest of the code instead. This effectively copies the one field in the struct to a local variable so that it is insulated from other threads.

Private helper class for use only by .

The private builder implementation.

The return value from the implementation of is . This is the return value for most instances of this enumerator.

The return value from the implementation of is . This is the return value for instances of this enumerator created by the implementation in .

Private helper class for use only by and .

The immutable collection this builder is based on.

The current mutable collection this builder is operating on. This field is initialized to a copy of the first time a change is made.

Represents a segmented hash set that is immutable; meaning it cannot be changed once it is created.

There are different scenarios best for and others best for . The following table summarizes the performance characteristics of : Operation Complexity Complexity Comments Contains O(1) O(log n) Directly index into the underlying segmented list Add() O(n) O(log n) Requires creating a new segmented hash set and cloning all impacted segments This type is backed by segmented arrays to avoid using the Large Object Heap without impacting algorithmic complexity. The type of the value in the set. This type has a documented contract of being exactly one reference-type field in size. Our own class depends on it, as well as others externally. IMPORTANT NOTICE FOR MAINTAINERS AND REVIEWERS: This type should be thread-safe. As a struct, it cannot protect its own fields from being changed from one thread while its members are executing on other threads because structs can change in place simply by reassigning the field containing this struct. Therefore it is extremely important that ⚠⚠ Every member should only dereference this ONCE ⚠⚠. If a member needs to reference the field, that counts as a dereference of this. Calling other instance members (properties or methods) also counts as dereferencing this. Any member that needs to use this more than once must instead assign this to a local variable and use that for the rest of the code instead. This effectively copies the one field in the struct to a local variable so that it is insulated from other threads.

The private builder implementation.

Private helper class for use only by and .

The immutable collection this builder is based on.

The current mutable collection this builder is operating on. This field is initialized to a copy of the first time a change is made.

Represents a segmented list that is immutable; meaning it cannot be changed once it is created.

There are different scenarios best for and others best for . The following table summarizes the performance characteristics of : Operation Complexity Complexity Comments Item O(1) O(log n) Directly index into the underlying segmented list Add() Currently O(n), but could be O(1) with a relatively large constant O(log n) Currently requires creating a new segmented list, but could be modified to only clone the segments with changes Insert() O(n) O(log n) Requires creating a new segmented list and cloning all impacted segments This type is backed by segmented arrays to avoid using the Large Object Heap without impacting algorithmic complexity. The type of the value in the list. This type has a documented contract of being exactly one reference-type field in size. Our own class depends on it, as well as others externally. IMPORTANT NOTICE FOR MAINTAINERS AND REVIEWERS: This type should be thread-safe. As a struct, it cannot protect its own fields from being changed from one thread while its members are executing on other threads because structs can change in place simply by reassigning the field containing this struct. Therefore it is extremely important that ⚠⚠ Every member should only dereference this ONCE ⚠⚠. If a member needs to reference the field, that counts as a dereference of this. Calling other instance members (properties or methods) also counts as dereferencing this. Any member that needs to use this more than once must instead assign this to a local variable and use that for the rest of the code instead. This effectively copies the one field in the struct to a local variable so that it is insulated from other threads.

The private builder implementation.

Private helper class for use only by and .

The immutable collection this builder is based on.

The current mutable collection this builder is operating on. This field is initialized to a copy of the first time a change is made.

Swaps the values in the two references if the first is greater than the second.

Swaps the values in the two references, regardless of whether the two references are the same.

Helper methods for use in array/span sorting routines.

Returns the integer (floor) log of the specified value, base 2. Note that by convention, input value 0 returns 0 since Log(0) is undefined. Does not directly use any hardware intrinsics, nor does it incur branching.

The value.

How many ints must be allocated to represent n bits. Returns (n+31)/32, but avoids overflow.

Returns approximate reciprocal of the divisor: ceil(2**64 / divisor).

This should only be used on 64-bit.

Performs a mod operation using the multiplier pre-computed with .

PERF: This improves performance in 64-bit scenarios at the expense of performance in 32-bit scenarios. Since we only build a single AnyCPU binary, we opt for improved performance in the 64-bit scenario.

Provides static methods to invoke members on value types that explicitly implement the member.

Normally, invocation of explicit interface members requires boxing or copying the value type, which is especially problematic for operations that mutate the value. Invocation through these helpers behaves like a normal call to an implicitly implemented member.

Provides static methods to invoke members on value types that explicitly implement the member.

Used internally to control behavior of insertion into a or .

The default insertion behavior.

Specifies that an existing entry with the same key should be overwritten if encountered.

Specifies that if an existing entry with the same key is encountered, an exception should be thrown.

Returns a by-ref to type that is a null reference.

Returns if a given by-ref to type is a null reference.

This check is conceptually similar to (void*)(&source) == nullptr.

Calculates the maximum number of elements of size which can fit into an array which has the following characteristics: The array can be allocated in the small object heap. The array length is a power of 2.

The size of the elements in the array. The segment size to use for small object heap segmented arrays.

Calculates a shift which can be applied to an absolute index to get the page index within a segmented array.

The number of elements in each page of the segmented array. Must be a power of 2. The shift to apply to the absolute index to get the page index within a segmented array.

Calculates a mask, which can be applied to an absolute index to get the index within a page of a segmented array.

The number of elements in each page of the segmented array. Must be a power of 2. The bit mask to obtain the index within a page from an absolute index within a segmented array.

Equality comparer for hashsets of hashsets

Destination array is not long enough to copy all the items in the collection. Check array index and length.

Hashtable's capacity overflowed and went negative. Check load factor, capacity and the current size of the table.

The given key '{0}' was not present in the dictionary.

Destination array was not long enough. Check the destination index, length, and the array's lower bounds.

Source array was not long enough. Check the source index, length, and the array's lower bounds.

The lower bound of target array must be zero.

Only single dimensional arrays are supported for the requested action.

The value "{0}" is not of type "{1}" and cannot be used in this generic collection.

An item with the same key has already been added. Key: {0}

Target array type is not compatible with the type of items in the collection.

Offset and length were out of bounds for the array or count is greater than the number of elements from index to the end of the source collection.

Number was less than the array's lower bound in the first dimension.

Larger than collection size.

Count must be positive and count must refer to a location within the string/array/collection.

Index was out of range. Must be non-negative and less than the size of the collection.

Index must be within the bounds of the List.

Non-negative number required.

capacity was less than the current size.

Operations that change non-concurrent collections must have exclusive access. A concurrent update was performed on this collection and corrupted its state. The collection's state is no longer correct.

Collection was modified; enumeration operation may not execute.

Enumeration has either not started or has already finished.

Failed to compare two elements in the array.

Mutating a key collection derived from a dictionary is not allowed.

Mutating a value collection derived from a dictionary is not allowed.

The specified arrays must have the same number of dimensions.

Collection was of a fixed size.

Object is not a array with the same number of elements as the array to compare it to.

Unable to sort because the IComparer.Compare() method returns inconsistent results. Either a value does not compare equal to itself, or one value repeatedly compared to another value yields different results. IComparer: '{0}'.

Cannot find the old value

Index was out of range. Must be non-negative and less than or equal to the size of the collection.

Mutates a value in-place with optimistic locking transaction semantics via a specified transformation function. The transformation is retried as many times as necessary to win the optimistic locking race.

The type of value stored by the list. The variable or field to be changed, which may be accessed by multiple threads. A function that mutates the value. This function should be side-effect free, as it may run multiple times when races occur with other threads. if the location's value is changed by applying the result of the function; otherwise, if the location's value remained the same because the last invocation of returned the existing value.

The type of value stored by the list. The type of argument passed to the . The variable or field to be changed, which may be accessed by multiple threads. A function that mutates the value. This function should be side-effect free, as it may run multiple times when races occur with other threads. The argument to pass to . if the location's value is changed by applying the result of the function; otherwise, if the location's value remained the same because the last invocation of returned the existing value.

Assigns a field or variable containing an immutable list to the specified value and returns the previous value.

The type of value stored by the list. The field or local variable to change. The new value to assign. The prior value at the specified .

Assigns a field or variable containing an immutable list to the specified value if it is currently equal to another specified value. Returns the previous value.

The type of value stored by the list. The field or local variable to change. The new value to assign. The value to check equality for before assigning. The prior value at the specified .

Assigns a field or variable containing an immutable list to the specified value if it is has not yet been initialized.

The type of value stored by the list. The field or local variable to change. The new value to assign. if the field was assigned the specified value; otherwise, if it was previously initialized.

The type of value stored by the set. The variable or field to be changed, which may be accessed by multiple threads. A function that mutates the value. This function should be side-effect free, as it may run multiple times when races occur with other threads. if the location's value is changed by applying the result of the function; otherwise, if the location's value remained the same because the last invocation of returned the existing value.

The type of value stored by the set. The type of argument passed to the . The variable or field to be changed, which may be accessed by multiple threads. A function that mutates the value. This function should be side-effect free, as it may run multiple times when races occur with other threads. The argument to pass to . if the location's value is changed by applying the result of the function; otherwise, if the location's value remained the same because the last invocation of returned the existing value.

Assigns a field or variable containing an immutable set to the specified value and returns the previous value.

The type of value stored by the set. The field or local variable to change. The new value to assign. The prior value at the specified .

Assigns a field or variable containing an immutable set to the specified value if it is currently equal to another specified value. Returns the previous value.

The type of value stored by the set. The field or local variable to change. The new value to assign. The value to check equality for before assigning. The prior value at the specified .

Assigns a field or variable containing an immutable set to the specified value if it is has not yet been initialized.

The type of value stored by the set. The field or local variable to change. The new value to assign. if the field was assigned the specified value; otherwise, if it was previously initialized.

The type of key stored by the dictionary. The type of value stored by the dictionary. The variable or field to be changed, which may be accessed by multiple threads. A function that mutates the value. This function should be side-effect free, as it may run multiple times when races occur with other threads. if the location's value is changed by applying the result of the function; otherwise, if the location's value remained the same because the last invocation of returned the existing value.

The type of key stored by the dictionary. The type of value stored by the dictionary. The type of argument passed to the . The variable or field to be changed, which may be accessed by multiple threads. A function that mutates the value. This function should be side-effect free, as it may run multiple times when races occur with other threads. The argument to pass to . if the location's value is changed by applying the result of the function; otherwise, if the location's value remained the same because the last invocation of returned the existing value.

Assigns a field or variable containing an immutable dictionary to the specified value and returns the previous value.

The type of key stored by the dictionary. The type of value stored by the dictionary. The field or local variable to change. The new value to assign. The prior value at the specified .

Assigns a field or variable containing an immutable dictionary to the specified value if it is currently equal to another specified value. Returns the previous value.

The type of key stored by the dictionary. The type of value stored by the dictionary. The field or local variable to change. The new value to assign. The value to check equality for before assigning. The prior value at the specified .

Assigns a field or variable containing an immutable dictionary to the specified value if it is has not yet been initialized.

The type of key stored by the dictionary. The type of value stored by the dictionary. The field or local variable to change. The new value to assign. if the field was assigned the specified value; otherwise, if it was previously initialized.

Defines a fixed-size collection with the same API surface and behavior as an "SZArray", which is a single-dimensional zero-based array commonly represented in C# as T[]. The implementation of this collection uses segmented arrays to avoid placing objects on the Large Object Heap.

The type of elements stored in the array.

Private helper class for use only by .

The number of elements in each page of the segmented array of type .

The segment size is calculated according to , performs the IL operation defined by . ECMA-335 defines this operation with the following note: sizeof returns the total size that would be occupied by each element in an array of this type – including any padding the implementation chooses to add. Specifically, array elements lie sizeof bytes apart.

The bit shift to apply to an array index to get the page index within .

The bit mask to apply to an array index to get the index within a page of .

An unsafe class that provides a set of methods to access the underlying data representations of immutable segmented collections.

Gets the backing storage array for a .

The type of elements stored in the array. The segmented array. The backing storage array for the segmented array. Note that replacing segments within the returned value will invalidate the data structure.

Gets either a ref to a in the or a ref null if it does not exist in the .

The dictionary to get the ref to from. The key used for lookup. The type of the keys in the dictionary. The type of the values in the dictionary. Items should not be added or removed from the while the ref is in use. The ref null can be detected using .

Gets either a read-only ref to a in the or a ref null if it does not exist in the .

The dictionary to get the ref to from. The key used for lookup. The type of the keys in the dictionary. The type of the values in the dictionary. The ref null can be detected using .

Gets either a ref to a in the or a ref null if it does not exist in the .

Gets an value wrapping the input .

The type of elements in the input segmented list. The input segmented list to wrap in the returned value. An value wrapping . When using this method, callers should take extra care to ensure that they're the sole owners of the input list, and that it won't be modified once the returned value starts being used. Doing so might cause undefined behavior in code paths which don't expect the contents of a given values to change after its creation. If is , the returned value will be uninitialized (i.e. its property will be ).

Gets the underlying for an input value.

The type of elements in the input value. The input value to get the underlying from. The underlying for , if present; otherwise, . When using this method, callers should make sure to not pass the resulting underlying list to methods that might mutate it. Doing so might cause undefined behavior in code paths using which don't expect the contents of the value to change. If is uninitialized (i.e. its property is ), the resulting will be .

Gets an value wrapping the input .

The type of elements in the input segmented hash set. The input segmented hash set to wrap in the returned value. An value wrapping . When using this method, callers should take extra care to ensure that they're the sole owners of the input set, and that it won't be modified once the returned value starts being used. Doing so might cause undefined behavior in code paths which don't expect the contents of a given values to change after its creation. If is , the returned value will be uninitialized (i.e. its property will be ).

Gets the underlying for an input value.

The type of elements in the input value. The input value to get the underlying from. The underlying for , if present; otherwise, . When using this method, callers should make sure to not pass the resulting underlying hash set to methods that might mutate it. Doing so might cause undefined behavior in code paths using which don't expect the contents of the value to change. If is uninitialized (i.e. its property is ), the resulting will be .

Gets an value wrapping the input .

The type of keys in the input segmented dictionary. The type of values in the input segmented dictionary. The input segmented dictionary to wrap in the returned value. An value wrapping . When using this method, callers should take extra care to ensure that they're the sole owners of the input dictionary, and that it won't be modified once the returned value starts being used. Doing so might cause undefined behavior in code paths which don't expect the contents of a given values to change after its creation. If is , the returned value will be uninitialized (i.e. its property will be ).

Gets the underlying for an input value.

The type of keys in the input value. The type of values in the input value. The input value to get the underlying from. The underlying for , if present; otherwise, . When using this method, callers should make sure to not pass the resulting underlying dictionary to methods that might mutate it. Doing so might cause undefined behavior in code paths using which don't expect the contents of the value to change. If is uninitialized (i.e. its property is ), the resulting will be .

Represents a collection of keys and values.

This collection has the same performance characteristics as , but uses segmented arrays to avoid allocations in the Large Object Heap. The type of the keys in the dictionary. The type of the values in the dictionary.

Private helper class for use only by .

doesn't devirtualize on .NET Framework, so we always ensure is initialized to a non- value.

Ensures that the dictionary can hold up to 'capacity' entries without any further expansion of its backing storage

Sets the capacity of this dictionary to what it would be if it had been originally initialized with all its entries

This method can be used to minimize the memory overhead once it is known that no new elements will be added. To allocate minimum size storage array, execute the following statements: dictionary.Clear(); dictionary.TrimExcess();

Sets the capacity of this dictionary to hold up 'capacity' entries without any further expansion of its backing storage

This method can be used to minimize the memory overhead once it is known that no new elements will be added.

0-based index of next entry in chain: -1 means end of chain also encodes whether this entry _itself_ is part of the free list by changing sign and subtracting 3, so -2 means end of free list, -3 means index 0 but on free list, -4 means index 1 but on free list, etc.

Cutoff point for stackallocs. This corresponds to the number of ints.

When constructing a hashset from an existing collection, it may contain duplicates, so this is used as the max acceptable excess ratio of capacity to count. Note that this is only used on the ctor and not to automatically shrink if the hashset has, e.g, a lot of adds followed by removes. Users must explicitly shrink by calling TrimExcess. This is set to 3 because capacity is acceptable as 2x rounded up to nearest prime.

doesn't devirtualize on .NET Framework, so we always ensure is initialized to a non- value.

Initializes the SegmentedHashSet from another SegmentedHashSet with the same element type and equality comparer.

Removes all elements from the object.

Determines whether the contains the specified element.

The element to locate in the object. true if the object contains the specified element; otherwise, false.

Gets the index of the item in , or -1 if it's not in the set.

Gets a reference to the specified hashcode's bucket, containing an index into .

Gets the number of elements that are contained in the set.

Adds the specified element to the .

The element to add to the set. true if the element is added to the object; false if the element is already present.

Searches the set for a given value and returns the equal value it finds, if any.

The value to search for. The value from the set that the search found, or the default value of when the search yielded no match. A value indicating whether the search was successful. This can be useful when you want to reuse a previously stored reference instead of a newly constructed one (so that more sharing of references can occur) or to look up a value that has more complete data than the value you currently have, although their comparer functions indicate they are equal.

Modifies the current object to contain all elements that are present in itself, the specified collection, or both.

The collection to compare to the current object.

Modifies the current object to contain only elements that are present in that object and in the specified collection.

The collection to compare to the current object.

Removes all elements in the specified collection from the current object.

The collection to compare to the current object.

Modifies the current object to contain only elements that are present either in that object or in the specified collection, but not both.

The collection to compare to the current object.

Determines whether a object is a subset of the specified collection.

The collection to compare to the current object. true if the object is a subset of ; otherwise, false.

Determines whether a object is a proper subset of the specified collection.

The collection to compare to the current object. true if the object is a proper subset of ; otherwise, false.

Determines whether a object is a proper superset of the specified collection.

The collection to compare to the current object. true if the object is a superset of ; otherwise, false.

Determines whether a object is a proper superset of the specified collection.

The collection to compare to the current object. true if the object is a proper superset of ; otherwise, false.

Determines whether the current object and a specified collection share common elements.

The collection to compare to the current object. true if the object and share at least one common element; otherwise, false.

Determines whether a object and the specified collection contain the same elements.

The collection to compare to the current object. true if the object is equal to ; otherwise, false.

Copies the elements of a object to an array, starting at the specified array index.

The destination array. The zero-based index in array at which copying begins.

Removes all elements that match the conditions defined by the specified predicate from a collection.

Gets the object that is used to determine equality for the values in the set.

Ensures that this hash set can hold the specified number of elements without growing.

Sets the capacity of a object to the actual number of elements it contains, rounded up to a nearby, implementation-specific value.

Returns an object that can be used for equality testing of a object.

Initializes buckets and slots arrays. Uses suggested capacity by finding next prime greater than or equal to capacity.

Adds the specified element to the set if it's not already contained.

The element to add to the set. The index into of the element. true if the element is added to the object; false if the element is already present.

Implementation Notes: If other is a hashset and is using same equality comparer, then checking subset is faster. Simply check that each element in this is in other. Note: if other doesn't use same equality comparer, then Contains check is invalid, which is why callers must take are of this. If callers are concerned about whether this is a proper subset, they take care of that.

If other is a hashset that uses same equality comparer, intersect is much faster because we can use other's Contains

Iterate over other. If contained in this, mark an element in bit array corresponding to its position in _slots. If anything is unmarked (in bit array), remove it. This attempts to allocate on the stack, if below StackAllocThreshold.

if other is a set, we can assume it doesn't have duplicate elements, so use this technique: if can't remove, then it wasn't present in this set, so add. As with other methods, callers take care of ensuring that other is a hashset using the same equality comparer.

Implementation notes: Used for symmetric except when other isn't a SegmentedHashSet. This is more tedious because other may contain duplicates. SegmentedHashSet technique could fail in these situations: 1. Other has a duplicate that's not in this: SegmentedHashSet technique would add then remove it. 2. Other has a duplicate that's in this: SegmentedHashSet technique would remove then add it back. In general, its presence would be toggled each time it appears in other. This technique uses bit marking to indicate whether to add/remove the item. If already present in collection, it will get marked for deletion. If added from other, it will get marked as something not to remove.

Determines counts that can be used to determine equality, subset, and superset. This is only used when other is an IEnumerable and not a SegmentedHashSet. If other is a SegmentedHashSet these properties can be checked faster without use of marking because we can assume other has no duplicates. The following count checks are performed by callers: 1. Equals: checks if unfoundCount = 0 and uniqueFoundCount = _count; i.e. everything in other is in this and everything in this is in other 2. Subset: checks if unfoundCount >= 0 and uniqueFoundCount = _count; i.e. other may have elements not in this and everything in this is in other 3. Proper subset: checks if unfoundCount > 0 and uniqueFoundCount = _count; i.e other must have at least one element not in this and everything in this is in other 4. Proper superset: checks if unfound count = 0 and uniqueFoundCount strictly less than _count; i.e. everything in other was in this and this had at least one element not contained in other. An earlier implementation used delegates to perform these checks rather than returning an ElementCount struct; however this was changed due to the perf overhead of delegates.

Allows us to finish faster for equals and proper superset because unfoundCount must be 0.

Checks if equality comparers are equal. This is used for algorithms that can speed up if it knows the other item has unique elements. I.e. if they're using different equality comparers, then uniqueness assumption between sets break.

Represents a strongly typed list of objects that can be accessed by index. Provides methods to search, sort, and manipulate lists.

This collection has the same performance characteristics as , but uses segmented arrays to avoid allocations in the Large Object Heap. The type of elements in the list.

Ensures that the capacity of this list is at least the specified . If the current capacity of the list is less than specified , the capacity is increased by continuously twice current capacity until it is at least the specified .

The minimum capacity to ensure. The new capacity of this list.

Increase the capacity of this list to at least the specified .

The minimum capacity to ensure.

Creates a shallow copy of a range of elements in the source .

The zero-based index at which the range starts. The length of the range. A shallow copy of a range of elements in the source . is less than 0. -or- is less than 0. and do not denote a valid range of elements in the . Whether or not the backing array should be created immediately, or should be deferred until the first time that is used. Note: if is then the array will be created in a non-threadsafe fashion (effectively different threads might observe a small window of time when different arrays could be returned. Derived types should only pass here if that behavior is acceptable for their use case.

Extension methods associated with ConsList.

The collection of extension methods for the type

If the given key is not found in the dictionary, add it with the given value and return the value. Otherwise return the existing value associated with that key.

If the given key is not found in the dictionary, add it with the result of invoking getValue and return the value. Otherwise return the existing value associated with that key.

A simple class to implement IGrouping.

This extension method is added so that it's preferred over LINQ's Any. This is more efficient than LINQ, especially in that it avoids the enumerator boxing allocation.

A dictionary that maps strings to all known spellings of that string. Can be used to efficiently store the set of known type names for a module for both VB and C# while also answering questions like "do you have a type called Goo" in either a case sensitive or insensitive manner.

The collection of extension methods for the type

Converts a sequence to an immutable array.

Elemental type of the sequence. The sequence to convert. An immutable copy of the contents of the sequence. If items is null (default) If the sequence is null, this will throw

Converts a sequence to an immutable array.

Elemental type of the sequence. The sequence to convert. An immutable copy of the contents of the sequence. If the sequence is null, this will return an empty array.

Converts a sequence to an immutable array.

Elemental type of the sequence. The sequence to convert. An immutable copy of the contents of the sequence. If the sequence is null, this will return the default (null) array.

Converts an array to an immutable array. The array must not be null.

The sequence to convert

Converts a array to an immutable array.

The sequence to convert If the sequence is null, this will return the default (null) array.

Converts an array to an immutable array.

The sequence to convert If the array is null, this will return an empty immutable array.

Reads bytes from specified .

The stream. Read-only content of the stream.

Maps an immutable array to another immutable array.

The array to map The mapping delegate If the items's length is 0, this will return an empty immutable array

Maps an immutable array to another immutable array.

The sequence to map The mapping delegate The extra input used by mapping delegate If the items's length is 0, this will return an empty immutable array.

Maps an immutable array to another immutable array.

The sequence to map The mapping delegate The extra input used by mapping delegate If the items's length is 0, this will return an empty immutable array.

Maps a subset of immutable array to another immutable array.

Type of the source array items Type of the transformed array items The array to transform The condition to use for filtering the array content. A transform function to apply to each element that is not filtered out by . If the items's length is 0, this will return an empty immutable array.

Maps a subset of immutable array to another immutable array.

Type of the source array items Type of the transformed array items Type of the extra argument The array to transform The condition to use for filtering the array content. A transform function to apply to each element that is not filtered out by . The extra input used by and . If the items's length is 0, this will return an empty immutable array.

Maps and flattens a subset of immutable array to another immutable array.

Type of the source array items Type of the transformed array items The array to transform A transform function to apply to each element. If the array's length is 0, this will return an empty immutable array.

Maps and flattens a subset of immutable array to another immutable array.

Maps an immutable array through a function that returns ValueTasks, returning the new ImmutableArray.

Zips two immutable arrays together through a mapping function, producing another immutable array.

If the items's length is 0, this will return an empty immutable array.

Creates a new immutable array based on filtered elements by the predicate. The array must not be null.

The array to process The delegate that defines the conditions of the element to search for.

Creates a new immutable array based on filtered elements by the predicate. The array must not be null.

The array to process The delegate that defines the conditions of the element to search for.

Casts the immutable array of a Type to an immutable array of its base type.

Determines whether this instance and another immutable array are equal.

The comparer to determine if the two arrays are equal. True if the two arrays are equal

Returns an empty array if the input array is null (default)

Returns an empty array if the input nullable value type is null or the underlying array is null (default)

Returns an array of distinct elements, preserving the order in the original array. If the array has no duplicates, the original array is returned. The original array must not be null.

Determines whether duplicates exist using default equality comparer.

Array to search for duplicates Whether duplicates were found

Determines whether duplicates exist using . Use other override if you don't need a custom comparer.

Array to search for duplicates Comparer to use in search Whether duplicates were found

Performs a comparison without allocating an intermediate .

A representation of a string of characters that requires O(1) extra space to concatenate two ropes.

A rope can wrap a simple string.

A rope can be formed from the concatenation of two ropes.

Two ropes are "the same" if they represent the same sequence of characters.

A rope that wraps a simple string.

A rope that represents the concatenation of two ropes.

Dictionary designed to hold small number of items. Compared to the regular Dictionary, average overhead per-item is roughly the same, but unlike regular dictionary, this one is based on an AVL tree and as such does not require rehashing when items are added. It does require rebalancing, but that is allocation-free. Major caveats: 1) There is no Remove method. (can be added, but we do not seem to use Remove that much) 2) foreach [keys|values|pairs] may allocate a small array. 3) Performance is no longer O(1). At a certain count it becomes slower than regular Dictionary. In comparison to regular Dictionary on my machine: On trivial number of elements (5 or so) it is more than 2x faster. The break even count is about 120 elements for read and 55 for write operations (with unknown initial size). At UShort.MaxValue elements, this dictionary is 6x slower to read and 4x slower to write Generally, this dictionary is a win if number of elements is small, not known beforehand or both. If the size of the dictionary is known at creation and it is likely to contain more than 10 elements, then regular Dictionary is a better choice.

Gets a mutable reference to a stored in a using variable.

This supporting method allows , a non-copyable implementing , to be used with using statements while still allowing them to be passed by reference in calls. The following two calls are equivalent:


             using var array = TemporaryArray<T>.Empty;
            
             // Using the 'Unsafe.AsRef' method
             Method(ref Unsafe.AsRef(in array));
            
             // Using this helper method
             Method(ref array.AsRef());

⚠ Do not move or rename this method without updating the corresponding RS0049 analyzer. The type of element stored in the temporary array. A read-only reference to a temporary array which is part of a using statement. A mutable reference to the temporary array.

Provides temporary storage for a collection of elements. This type is optimized for handling of small collections, particularly for cases where the collection will eventually be discarded or used to produce an .

This type stores small collections on the stack, with the ability to transition to dynamic storage if/when larger number of elements are added. The type of elements stored in the collection.

The number of elements the temporary can store inline. Storing more than this many elements requires the array transition to dynamic storage.

The first inline element.

This field is only used when is . In other words, this type stores elements inline or stores them in , but does not use both approaches at the same time.

The second inline element.

The third inline element.

The fourth inline element.

The number of inline elements held in the array. This value is only used when is .

A builder used for dynamic storage of collections that may exceed the limit for inline elements.

This field is initialized to non- the first time the needs to store more than four elements. From that point, is used instead of inline elements, even if items are removed to make the result smaller than four elements.

Create an with the elements currently held in the temporary array, and clear the array.

Transitions the current from inline storage to dynamic storage storage. An instance is taken from the shared pool, and all elements currently in inline storage are added to it. After this point, dynamic storage will be used instead of inline storage.

Throws .

This helper improves the ability of the JIT to inline callers.

A helper class that contains a topological sort algorithm.

Produce a topological sort of a given directed acyclic graph, given a set of nodes which include all nodes that have no predecessors. Any nodes not in the given set, but reachable through successors, will be added to the result. This is an iterative rather than recursive implementation, so it is unlikely to cause a stack overflow.

The type of the node Any subset of the nodes that includes all nodes with no predecessors A function that adds successor nodes to a provided . A list of all reachable nodes, in which each node always precedes its successors true if successful; false if not successful due to cycles in the graph

Implements a readonly collection over a set of existing collections. This can be used to prevent having to copy items from one collection over to another (thus bloating space). Note: this is a *collection*, not a *set*. There is no removal of duplicated elements. This allows us to be able to efficiently do operations like CopyTo, Count, etc. in O(c) time instead of O(n) (where 'c' is the number of collections and 'n' is the number of elements). If you have a few collections with many elements in them, then this is an appropriate collection for you.

Represents a single EditorConfig file, see https://editorconfig.org for details about the format.

Key that indicates if this config is a global config

Key that indicates the precedence of this config when is true

Filename that indicates this file is a user provided global config

A set of keys that are reserved for special interpretation for the editorconfig specification. All values corresponding to reserved keys in a (key,value) property pair are always lowercased during parsing.

This list was retrieved from https://github.com/editorconfig/editorconfig/wiki/EditorConfig-Properties at 2018-04-21 19:37:05Z. New keys may be added to this list in newer versions, but old ones will not be removed.

A set of values that are reserved for special use for the editorconfig specification and will always be lower-cased by the parser.

The directory the editorconfig was contained in, with all directory separators replaced with '/'.

The path passed to during construction.

Comparer for sorting files by path length.

Gets whether this editorconfig is a topmost editorconfig.

Gets whether this editorconfig is a global editorconfig.

Get the global level of this config, used to resolve conflicting keys

A user can explicitly set the global level via the . When no global level is explicitly set, we use a heuristic: Any file matching the is determined to be a user supplied global config and gets a level of 100 Any other file gets a default level of 0 This value is unused when is false.

Parses an editor config file text located at the given path. No parsing errors are reported. If any line contains a parse error, it is dropped.

Represents a named section of the editorconfig file, which consists of a name followed by a set of key-value pairs.

Used to compare s of sections. Specified by editorconfig to be a case-sensitive comparison.

Used to compare keys in . The editorconfig spec defines property keys as being compared case-insensitively according to Unicode lower-case rules.

For regular files, the name as present directly in the section specification of the editorconfig file. For sections in global configs, this is the unescaped full file path.

Keys and values for this section. All keys are lower-cased according to the EditorConfig specification and keys are compared case-insensitively. Values are lower-cased if the value appears in or if the corresponding key is in . Otherwise, the values are the literal values present in the source.

Takes a and creates a matcher that matches the given language. Returns null if the section name is invalid.

Test if a section name is an absolute path with no special chars

::= |

::= "*" | "**" | "?" | | | ::= any unicode character ::= "{" "}" ::= | "," ]]>

Compile a globbing character class of the form [...]. Returns true if the character class was successfully compiled. False if there was a syntax error. The starting character is expected to be directly after the '['.

Parses choice defined by the following grammar: ::= "{" "}" ::= | "," ]]>

Parses range defined by the following grammar. ::= "{" ".." "}" ::= "-" |

::= |

::= 0-9 ]]>

Call after getting from

Returns false if there are no more characters in the lex stream. Otherwise, produces the next character in the stream and returns true.

Returns the string representation of a decimal integer, or null if the current lexeme is not an integer.

Holds results from .

Options that customize diagnostic severity as reported by the compiler.

Options that do not have any special compiler behavior and are passed to analyzers as-is.

Any produced diagnostics while applying analyzer configuration.

Represents a set of , and can compute the effective analyzer options for a given source file. This is used to collect all the files for that would apply to a compilation.

The list of s in this set. This list has been sorted per . This does not include any of the global configs that were merged into .

s for each section. The entries in the outer array correspond to entries in , and each inner array corresponds to each .

Gets an that contain the options that apply globally

Returns a for a source file. This computes which rules applies to this file, and correctly applies precedence rules if there are multiple rules for the same file.

The path to a file such as a source file or additional file. Must be non-null. This method is safe to call from multiple threads.

Merge any partial global configs into a single global config, and remove the partial configs

An of containing a mix of regular and unmerged partial global configs Diagnostics produced during merge will be added to this bag A that contains the merged partial configs, or null if there were no partial configs

Builds a global analyzer config from a series of partial configs

Represents a combined global analyzer config.

We parse all s as individual files, according to the editorconfig spec. However, when viewing the configs as an if multiple files have the is_global property set to true we combine those files and treat them as a single 'logical' global config file. This type represents that combined file.

Describes a command line analyzer assembly specification.

Assembly file path.

The base class for representing command line arguments to a .

Drop to an interactive loop. If a script is specified in executes the script first.

Directory used to resolve relative paths stored in the arguments.

Except for paths stored in , all paths stored in the properties of this class are resolved and absolute. This is the directory that relative paths specified on command line were resolved against.

A list of pairs of paths. This stores the value of the command-line compiler option /pathMap:X1=Y1;X2=Y2... which causes a prefix of X1 followed by a path separator to be replaced by Y1 followed by a path separator, and so on for each following pair.

This option is used to help get build-to-build determinism even when the build directory is different from one build to the next. The prefix matching is case sensitive.

Sequence of absolute paths used to search for references.

Sequence of absolute paths used to search for sources specified as #load directives.

Sequence of absolute paths used to search for key files.

If true, use UTF-8 for output.

Compilation name or null if not specified.

Gets the emit options.

Name of the output file or null if not specified.

Path of the output ref assembly or null if not specified.

Path of the PDB file or null if same as output binary path with .pdb extension.

Path of the file containing information linking the compilation to source server that stores a snapshot of the source code included in the compilation.

Absolute path of the .ruleset file or null if not specified.

True to emit PDB information (to a standalone PDB file or embedded into the PE file).

Absolute path of the output directory (could only be null if there is an error reported).

Absolute path of the documentation comment XML file or null if not specified.

Absolute path of the directory to place generated files in, or null to not emit any generated files.

Options controlling the generation of a SARIF log file containing compilation or analysis diagnostics, or null if no log file is desired.

An absolute path of the app.config file or null if not specified.

Errors while parsing the command line arguments.

References to metadata supplied on the command line. Includes assemblies specified via /r and netmodules specified via /addmodule.

References to analyzers supplied on the command line.

A set of paths to EditorConfig-compatible analyzer config files.

A set of additional non-code text files that can be used by analyzers.

A set of files to embed in the PDB.

Report additional information related to analyzers, such as analyzer execution time.

Report additional information related to InternalsVisibleToAttributes for all assemblies the compiler sees in this compilation.

Skip execution of s.

If true, prepend the command line header logo during .

If true, append the command line help during

If true, append the compiler version during

If true, prepend the compiler-supported language versions during

The path to a Win32 resource.

The path to a .ico icon file.

The path to a Win32 manifest file to embed into the output portable executable (PE) file.

If true, do not embed any Win32 manifest, including one specified by or any default manifest.

Resources specified as arguments to the compilation.

Encoding to be used for source files or 'null' for autodetect/default.

Hash algorithm to use to calculate source file debug checksums and PDB checksum.

Arguments following a script file or separator "--". Null if the command line parser is not interactive.

Source file paths.

Includes files specified directly on command line as well as files matching patterns specified on command line using '*' and '?' wildcards or /recurse option.

Full path of a log of file paths accessed by the compiler, or null if file logging should be suppressed.

Two log files will be created: One with path and extension ".read" logging the files read, and second with path and extension ".write" logging the files written to during compilation.

If true, prints the full path of the file containing errors or warnings in diagnostics.

Options to the .

Specify the preferred output language name.

Returns a full path of the file that the compiler will generate the assembly to if compilation succeeds.

The method takes rather than using the value of since the latter might be unspecified, in which case actual output path can't be determined for C# command line without creating a compilation and finding an entry point. VB does not allow to be unspecified.

Returns a full path of the PDB file that the compiler will generate the debug symbols to if is true and the compilation succeeds.

Returns true if the PDB is generated to a PDB file, as opposed to embedded to the output binary and not generated at all.

Resolves metadata references stored in using given file resolver and metadata provider.

to use for assembly name and relative path resolution. Yields resolved metadata references or . is null.

Resolves metadata references stored in using given file resolver and metadata provider. If a non-null diagnostic bag is provided, it catches exceptions that may be generated while reading the metadata file and reports appropriate diagnostics. Otherwise, if is null, the exceptions are unhandled.

called by CommonCompiler with diagnostics and message provider

Resolves analyzer references stored in using given file resolver.

Load an assembly from a file path Yields resolved or .

Enumerates files in the specified directory and subdirectories whose name matches the given pattern.

Full path of the directory to enumerate. File name pattern. May contain wildcards '*' (matches zero or more characters) and '?' (matches any character). Specifies whether to search the specified only, or all its subdirectories as well. Sequence of file paths.

Parses a command line.

A collection of strings representing the command line arguments. The base directory used for qualifying file locations. The directory to search for mscorlib, or null if not available. A string representing additional reference paths. a object representing the parsed command line.

Determines if a is equal to the provided option name

Prefer this over the Equals methods on . The implementation allocates a . The 99% case here is that we are dealing with an ASCII string that matches the input hence it's worth special casing that here and falling back to the more complicated comparison when dealing with non-ASCII input

Trims all '.' and whitespace from the end of the path

Splits specified on treating two consecutive separators as if they were a single non-separating character. E.g. "a,,b,c" split on ',' yields ["a,b", "c"].

Returns false if any of the client arguments are invalid and true otherwise.

The original args to the client. The original args minus the client args, if no errors were encountered. Only defined if no errors were encountered. True if '/shared' was an argument, false otherwise. Only defined if no errors were encountered. The value to the '/keepalive' argument if one was specified, null otherwise. Only defined if errors were encountered. The error message for the encountered error. Only specified if is true and the session key was provided. Can be null

See

Remove the extraneous quotes and slashes from the argument. This function is designed to have compat behavior with the native compiler.

Mimics the function RemoveQuotes from the native C# compiler. The native VB equivalent of this function is called RemoveQuotesAndSlashes. It has virtually the same behavior except for a few quirks in error cases.

Split a string by a set of separators, taking quotes into account.

Tries to parse a UInt64 from string in either decimal, octal or hex format.

The string value. The result if parsing was successful. true if parsing was successful, otherwise false.

Tries to parse a UInt16 from string in either decimal, octal or hex format.

The string value. The result if parsing was successful. true if parsing was successful, otherwise false.

Sort so that more specific keys precede less specific. When mapping a path we find the first key in the array that is a prefix of the path. If multiple keys are prefixes of the path we want to use the longest (more specific) one for the mapping.

Describes a command line metadata reference (assembly or netmodule) specification.

Metadata file path or an assembly display name.

Metadata reference properties.

Describes a source file specification stored on command line arguments.

Resolved absolute path of the source file (does not contain wildcards).

Although this path is absolute it may not be normalized. That is, it may contain ".." and "." in the middle.

True if the input has been redirected from the standard input stream.

True if the file should be treated as a script file.

Base class for csc.exe, csi.exe, vbc.exe and vbi.exe implementations.

This implementation of will delay the creation of the PE / PDB file until the compiler determines the compilation has succeeded. This prevents the compiler from deleting output from the previous compilation when a new compilation fails. The method must be called to retrieve all diagnostics.

Looks for metadata references among the assembly file references given to the compilation when constructed. When scripts are included into a project we don't want #r's to reference other assemblies than those specified explicitly in the project references.

Fallback encoding that is lazily retrieved if needed. If is evaluated and stored, the value is used if a PDB is created for this compilation.

The set of source file paths that are in the set of embedded paths. This is used to prevent reading source files that are embedded twice.

The used to access the file system inside this instance.

Print compiler version

The type of the compiler class for version information in /help and /version. We don't simply use this.GetType() because that would break mock subclasses.

The version of this compiler with commit hash, used in logo and /version output.

Tool name used, along with assembly version, for error logging.

Tool version identifier used for error logging.

Resolves metadata references stored in command line arguments and reports errors for those that can't be resolved.

Reads content of a source file.

Source file information. Storage for diagnostics. File content or null on failure.

Reads content of a source file.

Source file information. Storage for diagnostics. If given opens successfully, set to normalized absolute path of the file, null otherwise. File content or null on failure.

Read all analyzer config files from the given paths.

Returns the fallback encoding for parsing source files, if used, or null if not used

Read a UTF-8 encoded file and return the text as a string.

Returns true if there were any errors, false otherwise.

Reports all IVT information for the given compilation and references, to aid in troubleshooting otherwise inexplicable IVT failures.

Returns true if there are any error diagnostics in the bag which cannot be suppressed and are guaranteed to break the build. Only diagnostics which have default severity error and are tagged as NotConfigurable fall in this bucket. This includes all compiler error diagnostics and specific analyzer error diagnostics that are marked as not configurable by the analyzer author.

Returns true if the bag has any diagnostics with effective Severity=Error. Also returns true for warnings or informationals or warnings promoted to error via /warnaserror which are not suppressed.

csc.exe and vbc.exe entry point.

Perform source generation, if the compiler supports it.

The compilation before any source generation has occurred. The base directory for the of generated files. The to use when parsing any generated sources. The generators to run A provider that returns analyzer config options. Any additional texts that should be passed to the generators when run. Any diagnostics that were produced during generation. A compilation that represents the original compilation with any additional, generated texts added to it.

Perform all the work associated with actual compilation (parsing, binding, compile, emit), resulting in diagnostics and analyzer output.

Returns the name with which the assembly should be output

When overridden by a derived class, this property can override the current thread's CurrentUICulture property for diagnostic message resource lookups.

Special informational diagnostic for each programmatic reported by a .

The path which contains the compiler binaries and response files.

The path in which the compilation takes place. This is also referred to as "baseDirectory" in the code base.

The path which contains mscorlib. This can be null when specified by the user or running in a CoreClr environment.

The temporary directory a compilation should use instead of Path.GetTempPath. The latter relies on global state individual compilations should ignore.

Base class for logging compiler diagnostics.

Contains information associated with a for the . It contains the following: 1. Analyzer execution time in seconds for the analyzer owning the descriptor. 2. Analyzer execution time in percentage of the total analyzer execution time. 3. Set of all effective severities for the diagnostic Id, configured through options from editorconfig, ruleset, command line options, etc. for either part of the compilation or the entire compilation. 4. A boolean value "HasAnyExternalSuppression" indicating if the diagnostic ID has any external non-source suppression from editorconfig, ruleset, command line options, etc., which disables the descriptor for either part of the compilation or the entire compilation. Note that this flag doesn't account for source suppressions from pragma directives, SuppressMessageAttributes, DiagnosticSuppressors, etc. which suppress individual instances of reported diagnostics.

Options controlling the generation of a SARIF log file containing compilation or analyzer diagnostics.

Absolute path of the error log file.

Version of the SARIF format used in the error log.

Initializes a new instance of the class.

Absolute path of the error log file. Version of the SARIF format used in the error log.

Compares descriptors by the values that we write to a SARIF log and nothing else. We cannot just use 's built-in implementation of for two reasons: 1. is part of that built-in equatability, but we do not write it out, and so descriptors differing only by MessageFormat (common) would lead to duplicate rule metadata entries in the log. 2. is *not* part of that built-in equatability, but we do write them out, and so descriptors differing only by CustomTags (rare) would cause only one set of tags to be reported in the log.

Base class for the and classes. The SarifV2ErrorLogger produces the standardized SARIF v2.1.0. The SarifV1ErrorLogger produces the non-standardized SARIF v1.0.0. It is retained (and in fact, is retained as the default) for compatibility with previous versions of the compiler. Customers who want to integrate with standardized SARIF tooling should specify /errorlog:logFilePath;version=2 on the command line to produce SARIF v2.1.0.

Used for logging compiler diagnostics to a stream in the unstandardized SARIF (Static Analysis Results Interchange Format) v1.0.0 format. https://github.com/sarif-standard/sarif-spec https://rawgit.com/sarif-standard/sarif-spec/main/Static%20Analysis%20Results%20Interchange%20Format%20(SARIF).html

To log diagnostics in the standardized SARIF v2.1.0 format, use the SarifV2ErrorLogger.

Represents a distinct set of s and provides unique string keys to distinguish them. The first added with a given value is given that value as its unique key. Subsequent adds with the same ID will have .NNN appended to their with an auto-incremented numeric value.

The total number of descriptors in the set.

Adds a descriptor to the set if not already present.

The unique key assigned to the given descriptor.

Converts the set to a list of (key, descriptor) pairs sorted by key.

Used for logging compiler diagnostics to a stream in the standardized SARIF (Static Analysis Results Interchange Format) v2.1.0 format. http://docs.oasis-open.org/sarif/sarif/v2.1.0/sarif-v2.1.0.html

Represents a distinct set of s and provides unique integer indices to distinguish them.

The total number of descriptors in the set.

Adds a descriptor to the set if not already present.

The unique key assigned to the given descriptor.

Converts the set to a list, sorted by index.

Specifies the version of the SARIF log file to produce.

The original, non-standardized version of the SARIF format.

The first standardized version of the SARIF format.

The default SARIF version, which is v1.0.0 for compatibility with previous versions of the compiler.

The latest supported SARIF version.

Try to parse the SARIF log file version from a string.

Used for logging all the paths which are "touched" (used) in any way in the process of compilation.

Adds a fully-qualified path to the Logger for a read file. Semantics are undefined after a call to .

Adds a fully-qualified path to the Logger for a written file. Semantics are undefined after a call to .

Adds a fully-qualified path to the Logger for a read and written file. Semantics are undefined after a call to .

Writes all of the paths the TouchedFileLogger to the given TextWriter in upper case. After calling this method the logger is in an undefined state.

The compilation object is an immutable representation of a single invocation of the compiler. Although immutable, a compilation is also on-demand, and will realize and cache data as necessary. A compilation can produce a new compilation from existing compilation with the application of small deltas. In many cases, it is more efficient than creating a new compilation from scratch, as the new compilation can reuse information from the old compilation.

Describes the kind of real signing that is being done during Emit. In the case of public signing this value will be .

This form of signing occurs in memory using the APIs. This is the default form of signing and will be used when a strong name key is provided in a file on disk.

This form of signing occurs using the COM APIs. This form of signing requires the unsigned PE to be written to disk before it can be signed (typically by writing it out to the %TEMP% folder). This signing is used when the key in a key container, the signing requires a counter signature or customers opted in via the UseLegacyStrongNameProvider feature flag.

This type abstracts away the legacy COM based signing implementation for PE streams. Under the hood a temporary file must be created on disk (at the last possible moment), emitted to, signed on disk and then copied back to the original . Only when legacy signing is enabled though.

Create the stream which should be used for Emit. This should only be called one time.

The returned here is owned by this type and should not be disposed by the caller.

Abstraction that allows the caller to delay the creation of the values until they are actually needed. The provided here is owned by this type and consumers should not dispose it.

This method will be called once during Emit at the time the Compilation needs to create a stream for writing. It will not be called in the case of user errors in code. Shall not be called when returns non-null.

Returns a . If one cannot be gotten or created then a diagnostic will be added to

Returns true if this is a case sensitive compilation, false otherwise. Case sensitivity affects compilation features such as name lookup as well as choosing what names to emit when there are multiple different choices (for example between a virtual method and an override).

Used for test purposes only to emulate missing members.

Gets the source language ("C#" or "Visual Basic").

This method generates a string that represents the input content to the compiler which impacts the output of the build. This string is effectively a content key for a with these values that can be used to identify the outputs. The returned string has the following properties: The format is undefined. Consumers should assume the format and content can change between compiler versions. It is designed to be human readable and diffable. This is to help developers understand the difference between two compilations which is impacting the deterministic output It is *not* in a minimal form. If used as a key in say a content addressable storage consumers should first pass it through a strong hashing function. Compilations which do not use the /deterministic option can still use this API but the results will change on every invocation.

The set of inputs that impact deterministic output are described in the following document - https://github.com/dotnet/roslyn/blob/main/docs/compilers/Deterministic%20Inputs.md There are a few dark corners of determinism that are not captured with this key as they are considered outside the scope of this work: Environment variables: clever developers can subvert determinism by manipulation of environment variables that impact program execution. For example changing normal library loading by manipulating the %LIBPATH% environment variable. Doing so can cause a change in deterministic output of compilation by changing compiler, runtime or generator dependencies. Manipulation of strong name keys: strong name keys are read "on demand" by the compiler and both normal compilation and this key can have non-deterministic output if they are manipulated at the correct point in program execution. That is an existing limitation of compilation that is tracked by https://github.com/dotnet/roslyn/issues/57940 This API can throw exceptions in a few cases like invalid file paths.

Checks options passed to submission compilation constructor. Throws an exception if the options are not applicable to submissions.

Creates a new compilation equivalent to this one with different symbol instances.

Returns a new compilation with a given event queue.

Returns a new compilation with a given semantic model provider.

Gets a new for the specified syntax tree.

The specified syntax tree. True if the SemanticModel should ignore accessibility rules when answering semantic questions.

Gets a for the given . If is non-null, it attempts to use to get a semantic model. Otherwise, it creates a new semantic model using .

Creates a new for the given . Unlike the and , it does not attempt to use the to get a semantic model, but instead always creates a new semantic model.

Returns a new INamedTypeSymbol representing an error type with the given name and arity in the given optional container.

Returns a new INamespaceSymbol representing an error (missing) namespace with the given name.

Simple assembly name, or null if not specified.

The name is used for determining internals-visible-to relationship with referenced assemblies. If the compilation represents an assembly the value of is its simple name. Unless specifies otherwise the module name written to metadata is with an extension based upon .

Creates a compilation with the specified assembly name.

The new assembly name. A new compilation.

Gets the options the compilation was created with.

Creates a new compilation with the specified compilation options.

The new options. A new compilation.

True if the compilation represents an interactive submission.

The previous submission, if any, or null.

Gets or allocates a runtime submission slot index for this compilation.

Non-negative integer if this is a submission and it or a previous submission contains code, negative integer otherwise.

The type object that represents the type of submission result the host requested.

The type of the globals object or null if not specified for this compilation.

Gets the syntax trees (parsed from source code) that this compilation was created with.

Creates a new compilation with additional syntax trees.

The new syntax trees. A new compilation.

Creates a new compilation with additional syntax trees.

The new syntax trees. A new compilation.

Creates a new compilation without the specified syntax trees. Preserves metadata info for use with trees added later.

The new syntax trees. A new compilation.

Creates a new compilation without the specified syntax trees. Preserves metadata info for use with trees added later.

The new syntax trees. A new compilation.

Creates a new compilation without any syntax trees. Preserves metadata info for use with trees added later.

Creates a new compilation with an old syntax tree replaced with a new syntax tree. Reuses metadata from old compilation object.

The new tree. The old tree. A new compilation.

Returns true if this compilation contains the specified tree. False otherwise.

A syntax tree.

Optional semantic model provider for this compilation.

The event queue that this compilation was created with.

If this value is not 0, we might be about to enqueue more events into . In this case, we need to wait for the count to go to zero before completing the queue. This is necessary in cases where multi-step operations that impact the queue occur. For example when a thread of execution is storing cached data on a symbol before pushing an event to the queue. If another thread were to come in between those two steps, see the cached data it could mistakenly believe the operation was complete and cause the queue to close. This counter ensures that the queue will remain open for the duration of a complex operation.

Metadata references passed to the compilation constructor.

Unique metadata references specified via #r directive in the source code of this compilation.

All reference directives used in this compilation.

Maps values of #r references to resolved metadata references.

All metadata references -- references passed to the compilation constructor as well as references specified via #r directives.

Creates a metadata reference for this compilation.

Optional aliases that can be used to refer to the compilation root namespace via extern alias directive. Embed the COM types from the reference so that the compiled application no longer requires a primary interop assembly (PIA).

Creates a new compilation with the specified references.

The new references. A new compilation.

Creates a new compilation with the specified references.

The new references. A new compilation.

Creates a new compilation with the specified references.

Creates a new compilation with additional metadata references.

The new references. A new compilation.

Creates a new compilation with additional metadata references.

The new references. A new compilation.

Creates a new compilation without the specified metadata references.

The new references. A new compilation.

Creates a new compilation without the specified metadata references.

The new references. A new compilation.

Creates a new compilation without any metadata references.

Creates a new compilation with an old metadata reference replaced with a new metadata reference.

The new reference. The old reference. A new compilation.

Gets the or for a metadata reference used to create this compilation.

The target reference. Assembly or module symbol corresponding to the given reference or null if there is none.

Gets the that corresponds to the assembly symbol.

The target symbol.

Assembly identities of all assemblies directly referenced by this compilation.

Includes identities of references passed in the compilation constructor as well as those specified via directives in source code.

The that represents the assembly being created.

Gets the for the module being created by compiling all of the source code.

The root namespace that contains all namespaces and types defined in source code or in referenced metadata, merged into a single namespace hierarchy.

Gets the corresponding compilation namespace for the specified module or assembly namespace.

Returns the Main method that will serves as the entry point of the assembly, if it is executable (and not a script).

Get the symbol for the predefined type from the Cor Library referenced by this compilation.

Get the symbol for the predefined type member from the COR Library referenced by this compilation.

Returns true if the type is System.Type.

Lookup member declaration in well known type used by this Compilation.

Lookup well-known type used by this Compilation.

Returns true if the specified type is equal to or derives from System.Attribute well-known type.

The INamedTypeSymbol for the .NET System.Object type, which could have a TypeKind of Error if there was no COR Library in this Compilation.

The TypeSymbol for the type 'dynamic' in this Compilation.

If the compilation is a VisualBasic compilation.

A symbol representing the script globals type.

A symbol representing the implicit Script class. This is null if the class is not defined in the compilation.

Resolves a symbol that represents script container (Script class). Uses the full name of the container class stored in to find the symbol.

The Script class symbol or null if it is not defined.

Returns a new ArrayTypeSymbol representing an array type tied to the base types of the COR Library in this Compilation.

This overload is for backwards compatibility. Do not remove.

Returns a new IPointerTypeSymbol representing a pointer type tied to a type in this Compilation.

If the compilation is a VisualBasic compilation.

Returns a new IFunctionPointerTypeSymbol representing a function pointer type tied to types in this Compilation.

If the compilation is a VisualBasic compilation. If: * is passed as the returnRefKind. * parameterTypes and parameterRefKinds do not have the same length. If returnType is , or if parameterTypes or parameterRefKinds are default, or if any of the types in parameterTypes are null.

Returns a new INamedTypeSymbol representing a native integer.

If the compilation is a VisualBasic compilation.

Gets the type within the compilation's assembly and all referenced assemblies (other than those that can only be referenced via an extern alias) using its canonical CLR metadata name. This lookup follows the following order: If the type is found in the compilation's assembly, that type is returned. Next, the core library (the library that defines System.Object and has no assembly references) is searched. If the type is found there, that type is returned. Finally, all remaining referenced non-extern assemblies are searched. If one and only one type matching the provided metadata name is found, that single type is returned. Accessibility is ignored for this check.

Null if the type can't be found or there was an ambiguity during lookup. Since VB does not have the concept of extern aliases, it considers all referenced assemblies. In C#, if the core library is referenced as an extern assembly, it will be searched. All other extern-aliased assemblies will not be searched. Because accessibility to the current assembly is ignored when searching for types that match the provided metadata name, if multiple referenced assemblies define the same type symbol (as often happens when users copy well-known types from the BCL or other sources) then this API will return null, even if all but one of those symbols would be otherwise inaccessible to user-written code in the current assembly. For fine-grained control over ambiguity resolution, consider using instead and filtering the results for the symbol required. Assemblies can contain multiple modules. Within each assembly, the search is performed based on module's position in the module list of that assembly. When a match is found in one module in an assembly, no further modules within that assembly are searched. Type forwarders are ignored, and not considered part of the assembly where the TypeForwardAttribute is written. Ambiguities are detected on each nested level. For example, if A+B is requested, and there are multiple As but only one of them has a B nested type, the lookup will be considered ambiguous and null will be returned.

Gets all types with the compilation's assembly and all referenced assemblies that have the given canonical CLR metadata name. Accessibility to the current assembly is ignored when searching for matching type names.

Empty array if no types match. Otherwise, all types that match the name, current assembly first if present. Assemblies can contain multiple modules. Within each assembly, the search is performed based on module's position in the module list of that assembly. When a match is found in one module in an assembly, no further modules within that assembly are searched. Type forwarders are ignored, and not considered part of the assembly where the TypeForwardAttribute is written.

Returns a new INamedTypeSymbol with the given element types and (optional) element names, locations, and nullable annotations.

Returns a new INamedTypeSymbol with the given element types, names, and locations.

This overload is for backwards compatibility. Do not remove.

Check that if any names are provided, and their number matches the expected cardinality. Returns a normalized version of the element names (empty array if all the names are null).

Returns a new INamedTypeSymbol with the given underlying type and (optional) element names, locations, and nullable annotations. The underlying type needs to be tuple-compatible.

Returns a new INamedTypeSymbol with the given underlying type and element names and locations. The underlying type needs to be tuple-compatible.

This overload is for backwards compatibility. Do not remove.

Returns a new anonymous type symbol with the given member types, names, source locations, and nullable annotations. Anonymous type members will be readonly by default. Writable properties are supported in VB and can be created by passing in in the appropriate locations in .

Returns a new anonymous type symbol with the given member types, names, and source locations. Anonymous type members will be readonly by default. Writable properties are supported in VB and can be created by passing in in the appropriate locations in .

This overload is for backwards compatibility. Do not remove.

Creates an whose is for a binary operator. Built-in operators are commonly created for symbols like bool int.operator ==(int v1, int v2) which the language implicitly supports, even if such a symbol is not explicitly defined for that type in either source or metadata.

The binary operator name. Should be one of the names from . The return type of the binary operator. The type of the left operand of the binary operator. The type of the right operand of the binary operator.

Creates an whose is for a unary operator. Built-in operators are commonly created for symbols like bool int.operator -(int value) which the language implicitly supports, even if such a symbol is not explicitly defined for that type in either source or metadata.

The unary operator name. Should be one of the names from . The return type of the unary operator. The type the operator applies to.

Classifies a conversion from to according to this compilation's programming language.

Source type of value to be converted Destination type of value to be converted A that classifies the conversion from the type to the type.

Returns true if there is an implicit (C#) or widening (VB) conversion from to . Returns false if either or is null, or if no such conversion exists.

Checks if is accessible from within . An optional qualifier of type is used to resolve protected access for instance members. All symbols are required to be from this compilation or some assembly referenced () by this compilation. is required to be an or .

Submissions can reference symbols from previous submissions and their referenced assemblies, even though those references are missing from . See https://github.com/dotnet/roslyn/issues/27356. This implementation works around that by permitting symbols from previous submissions as well. It is advised to avoid the use of this API within the compilers, as the compilers have additional requirements for access checking that are not satisfied by this implementation, including the avoidance of infinite recursion that could result from the use of the ISymbol APIs here, the detection of use-site diagnostics, and additional returned details (from the compiler's internal APIs) that are helpful for more precisely diagnosing reasons for accessibility failure.

Gets the diagnostics produced during the parsing stage.

Gets the diagnostics produced during symbol declaration.

Gets the diagnostics produced during the analysis of method bodies and field initializers.

Gets all the diagnostics for the compilation, including syntax, declaration, and binding. Does not include any diagnostics that might be produced during emit, see .

Unique metadata assembly references that are considered to be used by this compilation. For example, if a type declared in a referenced assembly is referenced in source code within this compilation, the reference is considered to be used. Etc. The returned set is a subset of references returned by API. The result is undefined if the compilation contains errors. The effect of imported namespaces on result of this API depends on whether reporting of unused imports is disabled for the compilation. The reporting of unused imports is disabled if is set to . When unused imports reporting is disabled, all referenced assemblies containing any types that belong to imported namespaces are included in the result. I.e. considered used. When unused imports reporting is enabled, imported namespaces do not have effect on the result of this API. Therefore, removing assembly references that aren't in the result, could potentially cause error "CS0246: The type or namespace name could not be found (are you missing a using directive or an assembly reference?)" on an unused namespace import. However, that import would be reported by compiler as unused for the compilation on which this API was invoked. In order to avoid the errors, it is recommended to remove unused assembly references and unused imports at the same time.

Filter out warnings based on the compiler options (/nowarn, /warn and /warnaserror) and the pragma warning directives. 'incoming' is freed.

Bag to which filtered diagnostics will be added. Diagnostics to be filtered. True if there are no unsuppressed errors (i.e., no errors which fail compilation).

Filter out warnings based on the compiler options (/nowarn, /warn and /warnaserror) and the pragma warning directives.

True if there are no unsuppressed errors (i.e., no errors which fail compilation).

Create a stream filled with default win32 resources.

There are two ways to sign PE files 1. By directly signing the 2. Write the unsigned PE to disk and use CLR COM APIs to sign. The preferred method is #1 as it's more efficient and more resilient (no reliance on %TEMP%). But we must continue to support #2 as it's the only way to do the following: - Access private keys stored in a key container - Do proper counter signature verification for AssemblySignatureKey attributes

Constructs the module serialization properties out of the compilation options of this compilation.

The value is not used by Windows loader, but the OS appcompat infrastructure uses it to identify apps. It is useful for us to have a mechanism to identify the compiler that produced the binary. This is the appropriate value to use for that. That is what it was invented for. We don't want to have the high bit set for this in case some users perform a signed comparison to determine if the value is less than some version. The C++ linker is at 0x0B. We'll start our numbering at 0x30 for C#, 0x50 for VB.

Return true if the compilation contains any code or types.

Report declaration diagnostics and compile and synthesize method bodies.

True if successful.

Update resources.

True if successful.

Generate XML documentation comments.

True if successful.

Reports all unused imports/usings so far (and thus it must be called as a last step of Emit)

Signals the event queue, if any, that we are done compiling. There should not be more compiling actions after this step. NOTE: once we signal about completion to analyzers they will cancel and thus in some cases we may be effectively cutting off some diagnostics. It is not clear if behavior is desirable. See: https://github.com/dotnet/roslyn/issues/11470

What tree to complete. null means complete all trees.

Emit the IL for the compiled source code into the specified stream.

Stream to which the compilation will be written. Stream to which the metadata-only output will be written. Stream to which the compilation's debug info will be written. Null to forego PDB generation. Stream to which the compilation's XML documentation will be written. Null to forego XML generation. Stream from which the compilation's Win32 resources will be read (in RES format). Null to indicate that there are none. The RES format begins with a null resource entry. Note that the caller is responsible for disposing this stream, if provided. List of the compilation's managed resources. Null to indicate that there are none. Emit options. Debug entry-point of the assembly. The method token is stored in the generated PDB stream. When a program launches with a debugger attached the debugger places the first breakpoint to the start of the debug entry-point method. The CLR starts executing the static Main method of type. When the first breakpoint is hit the debugger steps thru the code statement by statement until user code is reached, skipping methods marked by , and taking other debugging attributes into consideration. By default both entry points in an executable program (, , ) are the same method (Main). A non-executable program has no entry point. Runtimes that implement a custom loader may specify debug entry-point to force the debugger to skip over complex custom loader logic executing at the beginning of the .exe and thus improve debugging experience. Unlike ordinary entry-point which is limited to a non-generic static method of specific signature, there are no restrictions on the method other than having a method body (extern, interface, or abstract methods are not allowed). Stream containing information linking the compilation to a source control. Texts to embed in the PDB. Only supported when emitting Portable PDBs. To cancel the emit process.

This overload is only intended to be directly called by tests that want to pass . The map is used for storing a list of methods and their associated IL.

Emit the differences between the compilation and the previous generation for Edit and Continue. The differences are expressed as added and changed symbols, and are emitted as metadata, IL, and PDB deltas. A representation of the current compilation is returned as an EmitBaseline for use in a subsequent Edit and Continue.

Check compilation options and create .

if successful.

False when the "debug-analyzers" feature flag is set. When that flag is set, the compiler will not catch exceptions from analyzer execution to allow creating dumps.

The compiler needs to define an ordering among different partial class in different syntax trees in some cases, because emit order for fields in structures, for example, is semantically important. This function defines an ordering among syntax trees in this compilation.

Compare two source locations, using their containing trees, and then by Span.First within a tree. Can be used to get a total ordering on declarations, for example.

Return the lexically first of two locations.

Return the lexically first of multiple locations.

Return true if there is a source declaration symbol name that meets given predicate.

Return source declaration symbols whose name meets given predicate.

Return true if there is a source declaration symbol name that matches the provided name. This may be faster than when predicate is just a simple string check. is case sensitive or not depending on the target language.

Return source declaration symbols whose name matches the provided name. This may be faster than when predicate is just a simple string check. is case sensitive or not depending on the target language.

Given a reporting unreferenced s, returns the actual instances that were not referenced.

Returns the required language version found in a , if any is found. Returns null if none is found.

Determines whether the runtime this is targeting supports a particular capability.

Returns if an unknown capability is passed in.

The list of RetargetingAssemblySymbol objects created for this Compilation. RetargetingAssemblySymbols are created when some other compilation references this one, but the other references provided are incompatible with it. For example, compilation C1 references v1 of Lib.dll and compilation C2 references C1 and v2 of Lib.dll. In this case, in context of C2, all types from v1 of Lib.dll leaking through C1 (through method signatures, etc.) must be retargeted to the types from v2 of Lib.dll. This is what RetargetingAssemblySymbol is responsible for. In the example above, modules in C2 do not reference C1.AssemblySymbol, but reference a special RetargetingAssemblySymbol created for C1 by ReferenceManager. WeakReference is used to allow RetargetingAssemblySymbol to be collected when they become unused. Guarded by .

Adds given retargeting assembly for this compilation into the cache. must be locked while calling this method.

Adds cached retargeting symbols into the given list. must be locked while calling this method.

Indicates the reasons why a candidate (or set of candidate) symbols were not considered correct in SemanticInfo. Higher values take precedence over lower values, so if, for example, there a symbol with a given name that was inaccessible, and other with the wrong arity, only the inaccessible one would be reported in the SemanticInfo.

No CandidateSymbols.

Only a type or namespace was valid in the given location, but the candidate symbols was of the wrong kind.

Only an event was valid in the given location, but the candidate symbols was of the wrong kind.

The candidate symbol must be a WithEvents member, but it was not.

Only an attribute type was valid in the given location, but the candidate symbol was of the wrong kind.

The candidate symbol takes a different number of type parameters that was required.

The candidate symbol existed, but was not allowed to be created in a new expression. For example, interfaces, static classes, and unconstrained type parameters.

The candidate symbol existed, but was not allowed to be referenced. For example, the "get_XXX" method used to implement a property named "XXX" may not be directly referenced. Similarly, the type "System.Void" can not be directly referenced. Also occurs if "this" is used in a context (static method or field initializer) where "this" is not available.

The candidate symbol had an accessibility modifier (private, protected, ...) that made it inaccessible.

The candidate symbol was in a place where a value was required, but was not a value (e.g., was a type or namespace).

The candidate symbol was in a place where a variable (or sometimes, a property) was required, but was not allowed there because it isn't a symbol that can be assigned to. For example, the left hand side of an assignment, or a ref or out parameter.

The candidate symbol was used in a way that an invocable member (method, or variable of delegate type) was required, but the candidate symbol was not invocable.

The candidate symbol must be an instance variable, but was used as static, or the reverse.

Overload resolution did not choose a method. The candidate symbols are the methods there were considered during overload resolution (which may or may not be applicable methods).

Method could not be selected statically. The candidate symbols are the methods there were considered during overload resolution (which may or may not be applicable methods).

Multiple ambiguous symbols were available with the same name. This can occur if "using" statements bring multiple namespaces into scope, and the same type is available in multiple. This can also occur if multiple properties of the same name are available in a multiple interface inheritance situation.

CandidateSymbols are members of a group of results. This is used when there isn't a problem, but there is more than one result, for example nameof(int.ToString).

Maps an async/iterator method to the synthesized state machine type that implements the method.

Represents compilation options common to C# and VB.

The kind of assembly generated when emitted.

Name of the primary module, or null if a default name should be used.

The name usually (but not necessarily) includes an extension, e.g. "MyModule.dll". If is null the actual name written to metadata is derived from the name of the compilation () by appending a default extension for .

The full name of a global implicit class (script class). This class implicitly encapsulates top-level statements, type declarations, and member declarations. Could be a namespace qualified name.

The full name of a type that declares static Main method. Must be a valid non-generic namespace-qualified name. Null if any static Main method is a candidate for an entry point.

Specifies public key used to generate strong name for the compilation assembly, or empty if not specified.

If specified the values of and must be null. If is true the assembly is marked as fully signed but only signed with the public key (aka "OSS signing").

The name of the file containing the public and private keys to use to generate strong name of the compilation assembly and to sign it.

To sign the output supply either one of or . but not both. If both are specified is ignored. If is also set, must be the absolute path to key file.

The CSP container containing the key with which to sign the output.

To sign the output supply either one of or . but not both. If both are specified is ignored. This setting is obsolete and only supported on Microsoft Windows platform. Use to generate assemblies with strong name and a signing tool (Microsoft .NET Framework Strong Name Utility (sn.exe) or equivalent) to sign them.

Mark the compilation assembly as delay-signed.

If true the resulting assembly is marked as delay signed. If false and , , or is specified or attribute System.Reflection.AssemblyKeyFileAttribute or System.Reflection.AssemblyKeyNameAttribute is applied to the compilation assembly in source the resulting assembly is signed accordingly to the specified values/attributes. If null the semantics is specified by the value of attribute System.Reflection.AssemblyDelaySignAttribute applied to the compilation assembly in source. If the attribute is not present the value defaults to "false".

Mark the compilation assembly as fully signed, but only sign with the public key.

If true, the assembly is marked as signed, but is only signed with the public key. The key must be provided through either an absolute path in or directly via .

Whether bounds checking on integer arithmetic is enforced by default or not.

Specifies which version of the common language runtime (CLR) can run the assembly.

Specifies whether or not optimizations should be performed on the output IL. This is independent of whether or not PDB information is generated.

Global warning report option

Global warning level (a non-negative integer).

Specifies whether building compilation may use multiple threads.

Specifies whether the compilation should be deterministic.

Used for time-based version generation when contains a wildcard. If equal to default() the actual current local time will be used.

Emit mode that favors debuggability.

Specifies whether to import members with accessibility other than public or protected by default. Default value is . The value specified is not going to affect correctness of analysis performed by compilers because all members needed for correctness are going to be imported regardless. This setting can force compilation to import members that it normally doesn't.

Apply additional disambiguation rules during resolution of referenced assemblies.

Modifies the incoming diagnostic, for example escalating its severity, or discarding it (returning null) based on the compilation options.

The modified diagnostic, or null

Warning report option for each warning.

Provider to retrieve options for particular syntax trees.

Whether diagnostics suppressed in source, i.e. is true, should be reported.

Resolves paths to metadata references specified in source via #r directives. Null if the compilation can't contain references to metadata other than those explicitly passed to its factory (such as #r directives in sources).

Gets the resolver for resolving XML document references for the compilation. Null if the compilation is not allowed to contain XML file references, such as XML doc comment include tags and permission sets stored in an XML file.

Gets the resolver for resolving source document references for the compilation. Null if the compilation is not allowed to contain source file references, such as #line pragmas and #load directives.

Provides strong name and signature the source assembly. Null if assembly signing is not supported.

Used to compare assembly identities. May implement unification and portability policies specific to the target platform. if not specified.

Gets the default nullable context state in this compilation.

This context does not apply to files that are marked as generated. Nullable is off by default in those locations.

A set of strings designating experimental compiler features that are to be enabled.

Gets the source language ("C#" or "Visual Basic").

Creates a new options instance with the specified general diagnostic option.

Creates a new options instance with the specified diagnostic-specific options.

Creates a new options instance with the specified suppressed diagnostics reporting option.

Creates a new options instance with the concurrent build property set accordingly.

Creates a new options instance with the deterministic property set accordingly.

Creates a new options instance with the specified output kind.

Creates a new options instance with the specified platform.

Creates a new options instance with the specified public sign setting.

Creates a new options instance with optimizations enabled or disabled.

Performs validation of options compatibilities and generates diagnostics if needed

Errors collection related to an incompatible set of compilation options

Represents the possible compilation stages for which it is possible to get diagnostics (errors).

Provides information about statements which transfer control in and out of a region. This information is returned from a call to .

The set of statements inside the region what are the destination of branches outside the region.

The set of statements inside a region that jump to locations outside the region.

Indicates whether a region completes normally. Return true if and only if the end of the last statement in a region is reachable or the region contains no statements.

The set of return statements found within a region.

Returns true if and only if analysis was successful. Analysis can fail if the region does not properly span a single expression, a single statement, or a contiguous series of statements within the enclosing block.

Provides information about how data flows into and out of a region. This information is returned from a call to , or one of its language-specific overloads, where you pass the first and last statements of the region as parameters. "Inside" means those statements or ones between them. "Outside" are any other statements of the same method.

The set of local variables that are declared within a region. Note that the region must be bounded by a method's body or a field's initializer, so parameter symbols are never included in the result.

The set of local variables which are assigned a value outside a region that may be used inside the region.

The set of local variables which are assigned a value inside a region that may be used outside the region.

The set of local variables which are definitely assigned a value when a region is entered.

The set of local variables which are definitely assigned a value when a region is exited.

The set of local variables for which a value is always assigned inside a region.

The set of local variables that are read inside a region.

The set of local variables that are written inside a region.

The set of the local variables that are read outside a region.

The set of local variables that are written outside a region.

The set of the local variables that have been referenced in anonymous functions and therefore must be moved to a field of a frame class.

This is the union of and .

The set of variables that are captured inside a region.

The set of variables that are captured outside a region.

The set of non-constant local variables and parameters that have had their address (or the address of one of their fields) taken.

The set of local functions that are used.

The string returned from this function represents the inputs to the compiler which impact determinism. It is meant to be inline with the specification here: - https://github.com/dotnet/roslyn/blob/main/docs/compilers/Deterministic%20Inputs.md Options which can cause compilation failure, but doesn't impact the result of a successful compilation should be included. That is because it is interesting to describe error states not just success states. Think about caching build failures as well as build successes. When an option is omitted, say if there is no value for a public crypto key, we should emit the property with a null value vs. omitting the property. Either approach would produce correct results the preference is to be declarative that an option is omitted.

The default is to include all inputs to the compilation which impact the output of the compilation: binaries or diagnostics.

Ignore all file paths, but still include file names, in the deterministic key.

This is useful for scenarios where the consumer is interested in the content of the being the same but aren't concerned precisely with the file path of the content. A typical example of this type of consumer is one that operates in CI where the path changes frequently.

Ignore the versions of the tools contributing to the build (compiler and runtime)

Compiler output is not guaranteed to be deterministically equivalent between versions but very often is for wide ranges of versions. This option is useful for consumers who are comfortable ignoring the versions when looking at compiler output.

The result of the Compilation.Emit method.

True if the compilation successfully produced an executable. If false then the diagnostics should include at least one error diagnostic indicating the cause of the failure.

A list of all the diagnostics associated with compilations. This include parse errors, declaration errors, compilation errors, and emitting errors.

Key used to group anonymous delegate templates by properties that are easy to infer from both source symbols and metadata.

Name of the anonymous type field.

True if the anonymous type field was marked as 'Key' in VB.

is case insensitive.

Represents additional info needed by async method implementation methods (MoveNext methods) to properly emit necessary PDB data for async debugging.

IL offset of catch handler or -1

Set of IL offsets where await operators yield control

Set of IL offsets where await operators are to be resumed

Symbol changes when emitting EnC delta.

Previous EnC generation baseline, or null if this is not EnC delta.

True if this module is an EnC update.

EnC generation. 0 if the module is not an EnC delta, 1 if it is the first EnC delta, etc.

If this module represents an assembly, name of the assembly used in AssemblyDef table. Otherwise name of the module same as .

Name of the module. Used in ModuleDef table.

Public types defined in other modules making up this assembly and to which other assemblies may refer to via this assembly followed by types forwarded to another assembly.

Used to distinguish which style to pick while writing native PDB information.

The PDB content for custom debug information is different between Visual Basic and CSharp. E.g. C# always includes a CustomMetadata Header (MD2) that contains the namespace scope counts, where as VB only outputs namespace imports into the namespace scopes. C# defines forwards in that header, VB includes them into the scopes list. Currently the compiler doesn't allow mixing C# and VB method bodies. Thus this flag can be per module. It is possible to move this flag to per-method basis but native PDB CDI forwarding would need to be adjusted accordingly.

Linked assembly names to be stored to native PDB (VB only).

Project level imports (VB only, TODO: C# scripts).

Default namespace (VB only).

Additional top-level types injected by the Expression Evaluators.

Anonymous types defined in the compilation.

Top-level embedded types (e.g. attribute types that are not present in referenced assemblies).

Top-level named types defined in source.

A list of the files that constitute the assembly. Empty for netmodule. These are not the source language files that may have been used to compile the assembly, but the files that contain constituent modules of a multi-module assembly as well as any external resources. It corresponds to the File table of the .NET assembly file format.

Builds symbol definition to location map used for emitting token -> location info into PDB to be consumed by WinMdExp.exe tool (only applicable for /t:winmdobj)

Builds a list of types, and their documents, that would otherwise not be referenced by any document info of any methods in those types, or any nested types. This data is helpful for navigating to the source of types that have no methods in one or more of the source files they are contained in. For example: First.cs:


             partial class Outer
             {
                 partial class Inner
                 {
                     public void Method()
                     {
                     }
                 }
             }

/// Second.cs:


             partial class Outer
             {
                 partial class Inner
                 {
                 }
             }

When navigating to the definition of "Outer" we know about First.cs because of the MethodDebugInfo for Outer.Inner.Method() but there would be no document information for Second.cs so this method would return that information. When navigating to "Inner" we likewise know about First.cs because of the MethodDebugInfo, and we know about Second.cs because of the document info for its containing type, so this method would not return information for Inner. In fact this method will never return information for any nested type.

Number of debug documents in the module. Used to determine capacities of lists and indices when emitting debug info.

An approximate number of method definitions that can provide a basis for approximating the capacities of various databases used during Emit.

CorLibrary assembly referenced by this module.

Returns copy of User Strings referenced from the IL in the module.

Assembly reference aliases (C# only).

Common base class for C# and VB PE module builder.

Returns all top-level (not nested) types defined in the module.

Captures the set of synthesized definitions that should be added to a type during emit process.

Returns null if there are no compiler generated types.

Returns null if there are no synthesized fields.

Returns null if there are no synthesized properties.

Returns null if there are no synthesized methods.

Debugging information associated with the specified method that is emitted by the compiler to support Edit and Continue.

Deserializes Edit and Continue method debug information from specified blobs.

Local variable slot map. Lambda and closure map. Invalid data.

Deserializes Edit and Continue method debug information from specified blobs.

Local variable slot map. Lambda and closure map. State machine suspension points, if the method is the MoveNext method of the state machine. Invalid data. Invalid data. Invalid data.

Ordered by id.

Caches for named PE types.

Gets a for a given , if it is defined in the initial metadata or has been added since.

Returns method handle of a method symbol from the immediately preceding generation.

The method may have been defined in any preceding generation but symbol must be mapped to the immediately preceding one.

Enumerates method symbols synthesized for the body of a given in the previous generation that are not synthesized for the current method body (if any).

Method from the previous generation. Lambdas generated to the current version of the method. This includes both lambdas mapped to previous ones and newly introduced lambdas.

Constructs a deleted definition

The old definition of the member Cache of type definitions used in signatures of deleted members. Used so that if a method 'C M(C c)' is deleted we use the same instance for the method return type, and the parameter type.

Represents a type referenced from a deleted member (as distinct from a type that has been deleted). This is also why it doesn't inherit from

Type definitions containing any changes (includes added types).

Cache of type definitions used in signatures of deleted members. Used so that if a method 'C M(C c)' is deleted we use the same instance for the method return type, and the parameter type.

Return tokens for all updated debuggable methods.

Return tokens for all updated or added types.

Add an item from a previous generation that has been updated in this generation.

Represents a module from a previous compilation. Used in Edit and Continue to emit the differences in a subsequent compilation.

A map of the assembly identities of the baseline compilation to the identities of the original metadata AssemblyRefs. Only includes identities that differ between these two.

Creates an from the metadata of the module before editing and from a function that maps from a method to an array of local names.

Initial . The metadata of the module before editing. A function that for a method handle returns Edit and Continue debug information emitted by the compiler into the PDB. The function shall throw if the debug information can't be read for the specified method. This exception and are caught and converted to an emit diagnostic. Other exceptions are passed through. A function that for a method handle returns the signature of its local variables. The function shall throw if the information can't be read for the specified method. This exception and are caught and converted to an emit diagnostic. Other exceptions are passed through. True if the baseline PDB is portable. An for the module. Only the initial baseline is created using this method; subsequent baselines are created automatically when emitting the differences in subsequent compilations. When an active method (one for which a frame is allocated on a stack) is updated the values of its local variables need to be preserved. The mapping of local variable names to their slots in the frame is not included in the metadata and thus needs to be provided by . The is only needed for the initial generation. The mapping for the subsequent generations is carried over through . The compiler assigns slots to named local variables (including named temporary variables) it the order in which they appear in the source code. This property allows the compiler to reconstruct the local variable mapping for the initial generation. A subsequent generation may add a new variable in between two variables of the previous generation. Since the slots of the previous generation variables need to be preserved the only option is to add these new variables to the end. The slot ordering thus no longer matches the syntax ordering. It is therefore necessary to pass to the next generation (rather than e.g. create new s from scratch based on metadata produced by subsequent compilations). is null. is null. is null. Error reading module metadata. Module metadata is invalid. Module has been disposed.

The original metadata of the module.

Metadata generation ordinal. Zero for full metadata and non-zero for delta.

Unique Guid for this delta, or default(Guid) if full metadata.

The latest generation number of each symbol added via edit.

Maps a parent handle to a non-empty ordered array of row ids of custom attributes added since the initial baseline.

EnC metadata for methods added or updated since the initial generation, indexed by method row id.

Reads EnC debug information of a method from the initial baseline PDB. The function shall throw if the debug information can't be read for the specified method. This exception and are caught and converted to an emit diagnostic. Other exceptions are passed through. The function shall return an empty if the method that corresponds to the specified handle has no debug information.

A function that for a method handle returns the signature of its local variables. The function shall throw if the information can't be read for the specified method. This exception and are caught and converted to an emit diagnostic. Other exceptions are passed through. The function shall return a nil if the method that corresponds to the specified handle has no local variables.

Handles of methods with sequence points that have been updated in this delta.

Handles of types that were changed (updated or inserted) in this delta.

Info to write to the PDB.

Id of the parent closure. Only relevant when emitting EnC delta.

Metadata names of fields of a struct closure that store variables captured by the closure. Null for class closures. Only relevant when emitting EnC delta.

True if the closure being built is compatible with the previous one.

True if - The parent closure hasn't changed - Both closures are struct closures or neither is. - The set of variables captured by the new struct closure must be a subset of previously captured variables (the runtime doesn't allow adding fields to structs).

True if the lambda being built is compatible with the previous one.

True if - The closure ordinal of the previous lambda is the same as the current one. It is not necessary to check that the generation of the closure matches. Two closures of the same ordinal that differ in generation can only exist because the first closure was deleted (or regenerated due to a rude edit) in an earlier generation and the latter closure corresponding to the same scope was added in a subsequent generation. The above condition ensures that the current lambda syntax maps to an existing lambda syntax in the previous generation. The closure the previous lambda is emitted to couldn't have been deleted. Guarantees that the containing type of the synthesized method remains unchanged. - The sequence of struct closures the local function captures is preserved. Guarantees that the signature of the synthesized method remains unchanged.

When invoked on a node that represents an anonymous function or a query clause [1] with a of another anonymous function or a query clause of the same kind [2], returns the body of the [1] that positionally corresponds to the specified . E.g. join clause declares left expression and right expression -- each of these expressions is a lambda body. JoinClause1.GetCorrespondingLambdaBody(JoinClause2.RightExpression) returns JoinClause1.RightExpression.

Given a node that represents a variable declaration, lambda or a closure scope return the position to be used to calculate the node's syntax offset with respect to its containing member.

No change to symbol or members.

No change to symbol but may contain changed symbols.

Symbol updated.

Symbol added.

Maps definitions being emitted to the corresponding definitions defined in the previous generation (metadata or source).

Contains all symbols from the current compilation that were explicitly updated/added to the source and their containing types and namespaces.

A set of symbols whose name emitted to metadata must include a "#{generation}" suffix to avoid naming collisions with existing types. Populated based on semantic edits with .

A set of symbols, from the old compilation, that have been deleted from the new compilation keyed by the containing type from the new compilation. Populated based on semantic edits with .

Updated methods.

True if the symbol is a source symbol added during EnC session. The symbol may be declared in any source compilation in the current solution.

Returns true if the symbol or some child symbol has changed and needs to be compiled.

Calculate the set of changes up to top-level types. The result will be used as a filter when traversing the module. Note that these changes only include user-defined source symbols, not synthesized symbols since those will be generated during lowering of the changed user-defined symbols.

Return the symbol that contains this symbol as far as changes are concerned. For instance, an auto property is considered the containing symbol for the backing field and the accessor methods. By default, the containing symbol is simply Symbol.ContainingSymbol.

Merges synthesized or deleted members generated during lowering, or emit, of the current compilation with aggregate synthesized or deleted members from all previous source generations (gen >= 1).

Suppose {S -> {A, B, D}, T -> {E, F}} are all synthesized members in previous generations, and {S' -> {A', B', C}, U -> {G, H}} members are generated in the current compilation. Where X matches X' via this matcher, i.e. X' is from the new compilation and represents the same metadata entity as X in the previous compilation. Then the resulting collection shall have the following entries: {S' -> {A', B', C, D}, U -> {G, H}, T -> {E, F}}

In C#, this is the set of anonymous types only; in VB, this is the set of anonymous types and delegates.

In C#, the set of anonymous delegates with name fully determined by signature; in VB, this set is unused and empty.

A map of the assembly identities of the baseline compilation to the identities of the original metadata AssemblyRefs. Only includes identities that differ between these two.

Represents compilation emit options.

True to emit an assembly excluding executable code such as method bodies.

Tolerate errors, producing a PE stream and a success result even in the presence of (some) errors.

Unless set (private) members that don't affect the language semantics of the resulting assembly will be excluded when emitting metadata-only assemblies as primary output (with on). If emitting a secondary output, this flag is required to be false.

Type of instrumentation that should be added to the output binary.

Subsystem version

Specifies the size of sections in the output file.

Valid values are 0, 512, 1024, 2048, 4096 and 8192. If the value is 0 the file alignment is determined based upon the value of .

True to enable high entropy virtual address space for the output binary.

Specifies the preferred base address at which to load the output DLL.

Debug information format.

Assembly name override - file name and extension. If not specified the compilation name is used.

By default the name of the output assembly is . Only in rare cases it is necessary to override the name. CAUTION: If this is set to a (non-null) value other than the existing compilation output name, then internals-visible-to and assembly references may not work as expected. In particular, things that were visible at bind time, based on the name of the compilation, may not be visible at runtime and vice-versa.

The name of the PDB file to be embedded in the PE image, or null to use the default.

If not specified the file name of the source module with an extension changed to "pdb" is used.

A crypto hash algorithm used to calculate PDB Checksum stored in the PE/COFF File. If not specified (the value is default(HashAlgorithmName)) the checksum is not calculated.

Runtime metadata version.

The encoding used to parse source files that do not have a Byte Order Mark. If specified, is stored in the emitted PDB in order to allow recreating the original compilation.

If is not specified, the encoding used to parse source files that do not declare their encoding via Byte Order Mark and are not UTF-8 encoded.

Test only - allows us to test .

Sets the byte alignment for portable executable file sections.

Can be one of the following values: 0, 512, 1024, 2048, 4096, 8192

Error type symbols should be replaced with an object of this class in the translation layer for emit.

For the name we will use a word "Error" followed by a guid, generated on the spot.

A fake containing assembly for an ErrorType object.

For the name we will use a word "Error" followed by a guid, generated on the spot.

Specifies a kind of instrumentation to be applied in generated code.

No instrumentation.

Instruments the code to add test coverage.

Instruments all methods, local functions and lambdas in the code with calls to , to guard against accidental stack overflow.

Instruments code with calls to on a module-level defined to enable cancellation of code that hasn't necessarily been written as cancellable.

The is emitted to a static field <PrivateImplementationDetails>.ModuleCancellationToken.

Represents additional info needed by iterator method implementation methods (MoveNext methods) to properly emit necessary PDB data for iterator debugging.

Represents instrumentation of a method.

Kinds of instrumentation to apply to the entire method body.

This is only used for testing. This is only used for testing. This is only used for testing.

Returns null if member doesn't belong to an embedded NoPia type.

Describes rude edit to be reported at runtime.

Error message.

Describes rude edit to be reported at runtime.

Error message.

Describes a symbol edit between two compilations. For example, an addition of a method, an update of a method, removal of a type, etc.

The type of edit.

The symbol from the earlier compilation, or null if the edit represents an addition.

The symbol from the later compilation, or the symbol of the containing type from the later compilation if the edit represents a deletion.

A map from syntax node in the later compilation to syntax node in the previous compilation, or null if is false and the map is not needed or the source of the current method is the same as the source of the previous method.

The map does not need to map all syntax nodes in the active method, only those syntax nodes that declare a local or generate a long lived local.

Associates a syntax node in the later compilation to an error that should be reported at runtime by the IL generated for the node, if any.

Instrumentation update to be applied to a method. If not empty, and must be non-null s, and must be .

Initializes an instance of .

The type of edit. The symbol from the earlier compilation, or null if the edit represents an addition. The symbol from the later compilation, or the symbol of the containing type from the later compilation if is . A map from syntax node in the later compilation to syntax node in the previous compilation, or null if the method state (locals, closures, etc.) doesn't need to be preserved. Instrumentation update to be applied to a method. or is null and the edit isn't a or , respectively. is not a valid kind.

True if is not null.

s are considered equal if they are of the same and the corresponding and symbols are the same. The effects of edits that compare equal on the emitted metadata/IL are not necessarily the same.

No change.

Symbol is updated.

Symbol is inserted.

Symbol is deleted.

Existing symbol is replaced by its new version.

Information associated with method body of a state machine MoveNext method.

Original async/iterator method transformed into MoveNext()

Represents an invalid operation with one or more child operations. Current usage: C# invalid expression or invalid statement VB invalid expression or invalid statement

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Represents a block containing a sequence of operations and local declarations. Current usage: C# "{ ... }" block statement VB implicit block statement for method bodies and other block scoped statements

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Operations contained within the block.

Local declarations contained within the block.

Represents a variable declaration statement. Current Usage: C# local declaration statement C# fixed statement C# using statement C# using declaration VB Dim statement VB Using statement

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Variable declaration in the statement.

In C#, this will always be a single declaration, with all variables in .

Represents a switch operation with a value to be switched upon and switch cases. Current usage: C# switch statement VB Select Case statement

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Locals declared within the switch operation with scope spanning across all .

Value to be switched upon.

Cases of the switch.

Exit label for the switch statement.

Represents a loop operation. Current usage: C# 'while', 'for', 'foreach' and 'do' loop statements VB 'While', 'ForTo', 'ForEach', 'Do While' and 'Do Until' loop statements

This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Kind of the loop.

Body of the loop.

Declared locals.

Loop continue label.

Loop exit/break label.

Represents a for each loop. Current usage: C# 'foreach' loop statement VB 'For Each' loop statement

This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Refers to the operation for declaring a new local variable or reference an existing variable or an expression.

Collection value over which the loop iterates.

Optional list of comma separated next variables at loop bottom in VB. This list is always empty for C#.

Whether this for each loop is asynchronous. Always false for VB.

Represents a for loop. Current usage: C# 'for' loop statement

This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

List of operations to execute before entry to the loop. For C#, this comes from the first clause of the for statement.

Locals declared within the loop Condition and are in scope throughout the , and . They are considered to be declared per iteration.

Condition of the loop. For C#, this comes from the second clause of the for statement.

List of operations to execute at the bottom of the loop. For C#, this comes from the third clause of the for statement.

Represents a for to loop with loop control variable and initial, limit and step values for the control variable. Current usage: VB 'For ... To ... Step' loop statement

This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Refers to the operation for declaring a new local variable or reference an existing variable or an expression.

Operation for setting the initial value of the loop control variable. This comes from the expression between the 'For' and 'To' keywords.

Operation for the limit value of the loop control variable. This comes from the expression after the 'To' keyword.

Operation for the step value of the loop control variable. This comes from the expression after the 'Step' keyword, or inferred by the compiler if 'Step' clause is omitted.

if arithmetic operations behind this loop are 'checked'.

Optional list of comma separated next variables at loop bottom.

Represents a while or do while loop. Current usage: C# 'while' and 'do while' loop statements VB 'While', 'Do While' and 'Do Until' loop statements

This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Condition of the loop. This can only be null in error scenarios.

True if the is evaluated at start of each loop iteration. False if it is evaluated at the end of each loop iteration.

True if the loop has 'Until' loop semantics and the loop is executed while is false.

Additional conditional supplied for loop in error cases, which is ignored by the compiler. For example, for VB 'Do While' or 'Do Until' loop with syntax errors where both the top and bottom conditions are provided. The top condition is preferred and exposed as and the bottom condition is ignored and exposed by this property. This property should be null for all non-error cases.

Represents an operation with a label. Current usage: C# labeled statement VB label statement

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Label that can be the target of branches.

Operation that has been labeled. In VB, this is always null.

Represents a branch operation. Current usage: C# goto, break, or continue statement VB GoTo, Exit ***, or Continue *** statement

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Label that is the target of the branch.

Kind of the branch.

Represents an empty or no-op operation. Current usage: C# empty statement

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Represents a return from the method with an optional return value. Current usage: C# return statement and yield statement VB Return statement

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Value to be returned.

Represents a of operations that are executed while holding a lock onto the . Current usage: C# lock statement VB SyncLock statement

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Operation producing a value to be locked.

Body of the lock, to be executed while holding the lock.

Represents a try operation for exception handling code with a body, catch clauses and a finally handler. Current usage: C# try statement VB Try statement

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Body of the try, over which the handlers are active.

Catch clauses of the try.

Finally handler of the try.

Exit label for the try. This will always be null for C#.

Represents a of operations that are executed while using disposable . Current usage: C# using statement VB Using statement

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Declaration introduced or resource held by the using.

Body of the using, over which the resources of the using are maintained.

Locals declared within the with scope spanning across this entire .

Whether this using is asynchronous. Always false for VB.

Represents an operation that drops the resulting value and the type of the underlying wrapped . Current usage: C# expression statement VB expression statement

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Underlying operation with a value and type.

Represents a local function defined within a method. Current usage: C# local function statement

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Local function symbol.

Body of the local function.

This can be null in error scenarios, or when the method is an extern method.

An extra body for the local function, if both a block body and expression body are specified in source.

This is only ever non-null in error situations.

Represents an operation to stop or suspend execution of code. Current usage: VB Stop statement

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Represents an operation that stops the execution of code abruptly. Current usage: VB End Statement

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Represents an operation for raising an event. Current usage: VB raise event statement

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Reference to the event to be raised.

Arguments of the invocation, excluding the instance argument. Arguments are in evaluation order.

If the invocation is in its expanded form, then params/ParamArray arguments would be collected into arrays. Default values are supplied for optional arguments missing in source.

Represents a textual literal numeric, string, etc. Current usage: C# literal expression VB literal expression

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Represents a type conversion. Current usage: C# conversion expression VB conversion expression

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Value to be converted.

Operator method used by the operation, null if the operation does not use an operator method.

Type parameter which runtime type will be used to resolve virtual invocation of the , if any. Null if is resolved statically, or is null.

Gets the underlying common conversion information.

If you need conversion information that is language specific, use either or .

False if the conversion will fail with a at runtime if the cast fails. This is true for C#'s as operator and for VB's TryCast operator.

True if the conversion can fail at runtime with an overflow exception. This corresponds to C# checked and unchecked blocks.

Represents an invocation of a method. Current usage: C# method invocation expression C# collection element initializer. For example, in the following collection initializer: new C() { 1, 2, 3 }, we will have 3 nodes, each of which will be a call to the corresponding Add method with either 1, 2, 3 as the argument VB method invocation expression VB collection element initializer. Similar to the C# example, New C() From {1, 2, 3} will have 3 nodes with 1, 2, and 3 as their arguments, respectively

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Method to be invoked.

Type parameter which runtime type will be used to resolve virtual invocation of the . Null if is resolved statically, or is an instance method.

'This' or 'Me' instance to be supplied to the method, or null if the method is static.

True if the invocation uses a virtual mechanism, and false otherwise.

Arguments of the invocation, excluding the instance argument. Arguments are in evaluation order.

If the invocation is in its expanded form, then params/ParamArray arguments would be collected into arrays. Default values are supplied for optional arguments missing in source.

Represents a reference to an array element. Current usage: C# array element reference expression VB array element reference expression

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Array to be indexed.

Indices that specify an individual element.

Represents a reference to a declared local variable. Current usage: C# local reference expression VB local reference expression

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Referenced local variable.

True if this reference is also the declaration site of this variable. This is true in out variable declarations and in deconstruction operations where a new variable is being declared.

Represents a reference to a parameter. Current usage: C# parameter reference expression VB parameter reference expression

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Referenced parameter.

Represents a reference to a member of a class, struct, or interface. Current usage: C# member reference expression VB member reference expression

This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Instance of the type. Null if the reference is to a static/shared member.

Referenced member.

Type parameter which runtime type will be used to resolve virtual invocation of the . Null if is resolved statically, or is an instance member.

Represents a reference to a field. Current usage: C# field reference expression VB field reference expression

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Referenced field.

If the field reference is also where the field was declared.

This is only ever true in CSharp scripts, where a top-level statement creates a new variable in a reference, such as an out variable declaration or a deconstruction declaration.

Represents a reference to a method other than as the target of an invocation. Current usage: C# method reference expression VB method reference expression

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Referenced method.

Indicates whether the reference uses virtual semantics.

Represents a reference to a property. Current usage: C# property reference expression VB property reference expression

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Referenced property.

Arguments of the indexer property reference, excluding the instance argument. Arguments are in evaluation order.

If the invocation is in its expanded form, then params/ParamArray arguments would be collected into arrays. Default values are supplied for optional arguments missing in source.

Represents a reference to an event. Current usage: C# event reference expression VB event reference expression

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Referenced event.

Represents an operation with one operand and a unary operator. Current usage: C# unary operation expression VB unary operation expression

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Kind of unary operation.

Operand.

if this is a 'lifted' unary operator. When there is an operator that is defined to work on a value type, 'lifted' operators are created to work on the versions of those value types.

if overflow checking is performed for the arithmetic operation.

Operator method used by the operation, null if the operation does not use an operator method.

Type parameter which runtime type will be used to resolve virtual invocation of the , if any. Null if is resolved statically, or is null.

Represents an operation with two operands and a binary operator that produces a result with a non-null type. Current usage: C# binary operator expression VB binary operator expression

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Kind of binary operation.

Left operand.

Right operand.

if this is a 'lifted' binary operator. When there is an operator that is defined to work on a value type, 'lifted' operators are created to work on the versions of those value types.

if this is a 'checked' binary operator.

if the comparison is text based for string or object comparison in VB.

Operator method used by the operation, null if the operation does not use an operator method.

Type parameter which runtime type will be used to resolve virtual invocation of the or corresponding true/false operator, if any. Null if operators are resolved statically, or are not used.

Represents a conditional operation with: to be tested operation to be executed when is true and operation to be executed when the is false Current usage: C# ternary expression a ? b : c and if statement VB ternary expression If(a, b, c) and If Else statement

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Condition to be tested.

Operation to be executed if the is true.

Operation to be executed if the is false.

Is result a managed reference

Represents a coalesce operation with two operands: , which is the first operand that is unconditionally evaluated and is the result of the operation if non null , which is the second operand that is conditionally evaluated and is the result of the operation if is null Current usage: C# null-coalescing expression Value ?? WhenNull VB binary conditional expression If(Value, WhenNull)

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Operation to be unconditionally evaluated.

Operation to be conditionally evaluated if evaluates to null/Nothing.

Conversion associated with when it is not null/Nothing. Identity if result type of the operation is the same as type of . Otherwise, if type of is nullable, then conversion is applied to an unwrapped , otherwise to the itself.

Represents an anonymous function operation. Current usage: C# lambda expression VB anonymous delegate expression

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Symbol of the anonymous function.

Body of the anonymous function.

Represents creation of an object instance. Current usage: C# new expression VB New expression

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Constructor to be invoked on the created instance.

Object or collection initializer, if any.

Arguments of the object creation, excluding the instance argument. Arguments are in evaluation order.

If the invocation is in its expanded form, then params/ParamArray arguments would be collected into arrays. Default values are supplied for optional arguments missing in source.

Represents a creation of a type parameter object, i.e. new T(), where T is a type parameter with new constraint. Current usage: C# type parameter object creation expression VB type parameter object creation expression

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Object or collection initializer, if any.

Represents the creation of an array instance. Current usage: C# array creation expression VB array creation expression

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Sizes of the dimensions of the created array instance.

Values of elements of the created array instance.

Represents an implicit/explicit reference to an instance. Current usage: C# this or base expression VB Me, MyClass, or MyBase expression C# object or collection or 'with' expression initializers VB With statements, object or collection initializers

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

The kind of reference that is being made.

Represents an operation that tests if a value is of a specific type. Current usage: C# "is" operator expression VB "TypeOf" and "TypeOf IsNot" expression

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Value to test.

Type for which to test.

Flag indicating if this is an "is not" type expression. True for VB "TypeOf ... IsNot ..." expression. False, otherwise.

Represents an await operation. Current usage: C# await expression VB await expression

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Awaited operation.

Represents a base interface for assignments. Current usage: C# simple, compound and deconstruction assignment expressions VB simple and compound assignment expressions

This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Target of the assignment.

Value to be assigned to the target of the assignment.

Represents a simple assignment operation. Current usage: C# simple assignment expression VB simple assignment expression

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Is this a ref assignment

Represents a compound assignment that mutates the target with the result of a binary operation. Current usage: C# compound assignment expression VB compound assignment expression

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Conversion applied to before the operation occurs.

Conversion applied to the result of the binary operation, before it is assigned back to .

Kind of binary operation.

if this assignment contains a 'lifted' binary operation.

if overflow checking is performed for the arithmetic operation.

Operator method used by the operation, null if the operation does not use an operator method.

Type parameter which runtime type will be used to resolve virtual invocation of the , if any. Null if is resolved statically, or is null.

Represents a parenthesized operation. Current usage: VB parenthesized expression

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Operand enclosed in parentheses.

Represents a binding of an event. Current usage: C# event assignment expression VB Add/Remove handler statement

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Reference to the event being bound.

Handler supplied for the event.

True for adding a binding, false for removing one.

Represents a conditionally accessed operation. Note that is used to refer to the value of within . Current usage: C# conditional access expression (? or ?. operator) VB conditional access expression (? or ?. operator)

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Operation that will be evaluated and accessed if non null.

Operation to be evaluated if is non null.

Represents the value of a conditionally-accessed operation within . For a conditional access operation of the form someExpr?.Member, this operation is used as the InstanceReceiver for the right operation Member. See https://github.com/dotnet/roslyn/issues/21279#issuecomment-323153041 for more details. Current usage: C# conditional access instance expression VB conditional access instance expression

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Represents an interpolated string. Current usage: (1) C# interpolated string expression. (2) VB interpolated string expression.

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Constituent parts of interpolated string, each of which is an .

Represents a creation of anonymous object. Current usage: C# new { ... } expression VB New With { ... } expression

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Property initializers. Each initializer is an , with an as the target whose Instance is an with kind.

Represents an initialization for an object or collection creation. Current usage: C# object or collection initializer expression. For example, object initializer { X = x } within object creation new Class() { X = x } and collection initializer { x, y, 3 } within collection creation new MyList() { x, y, 3 } VB object or collection initializer expression

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Object member or collection initializers.

Represents an initialization of member within an object initializer with a nested object or collection initializer. Current usage: C# nested member initializer expression. For example, given an object creation with initializer new Class() { X = x, Y = { x, y, 3 }, Z = { X = z } }, member initializers for Y and Z, i.e. Y = { x, y, 3 }, and Z = { X = z } are nested member initializers represented by this operation VB object or collection initializer expression

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Initialized member reference or an invalid operation for error cases.

Member initializer.

Obsolete interface that used to represent a collection element initializer. It has been replaced by and , as appropriate. Current usage: None. This API has been obsoleted in favor of and .

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Represents an operation that gets a string value for the name. Current usage: C# nameof expression VB NameOf expression

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Argument to the name of operation.

Represents a tuple with one or more elements. Current usage: C# tuple expression VB tuple expression

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Tuple elements.

Natural type of the tuple, or null if tuple doesn't have a natural type. Natural type can be different from depending on the conversion context, in which the tuple is used.

Represents an object creation with a dynamically bound constructor. Current usage: C# new expression with dynamic argument(s) VB late bound New expression

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Object or collection initializer, if any.

Dynamically bound arguments, excluding the instance argument.

Represents a reference to a member of a class, struct, or module that is dynamically bound. Current usage: C# dynamic member reference expression VB late bound member reference expression

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Instance receiver, if it exists.

Referenced member.

Type arguments.

The containing type of the referenced member, if different from type of the .

Represents a invocation that is dynamically bound. Current usage: C# dynamic invocation expression C# dynamic collection element initializer. For example, in the following collection initializer: new C() { do1, do2, do3 } where the doX objects are of type dynamic, we'll have 3 with do1, do2, and do3 as their arguments VB late bound invocation expression VB dynamic collection element initializer. Similar to the C# example, New C() From {do1, do2, do3} will generate 3 nodes with do1, do2, and do3 as their arguments, respectively

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Dynamically or late bound operation.

Dynamically bound arguments, excluding the instance argument.

Represents an indexer access that is dynamically bound. Current usage: C# dynamic indexer access expression

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Dynamically indexed operation.

Dynamically bound arguments, excluding the instance argument.

Represents an unrolled/lowered query operation. For example, for a C# query expression "from x in set where x.Name != null select x.Name", the Operation tree has the following shape: ITranslatedQueryExpression IInvocationExpression ('Select' invocation for "select x.Name") IInvocationExpression ('Where' invocation for "where x.Name != null") IInvocationExpression ('From' invocation for "from x in set") Current usage: C# query expression VB query expression

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Underlying unrolled operation.

Represents a delegate creation. This is created whenever a new delegate is created. Current usage: C# delegate creation expression VB delegate creation expression

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

The lambda or method binding that this delegate is created from.

Represents a default value operation. Current usage: C# default value expression

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Represents an operation that gets for the given . Current usage: C# typeof expression VB GetType expression

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Type operand.

Represents an operation to compute the size of a given type. Current usage: C# sizeof expression

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Type operand.

Represents an operation that creates a pointer value by taking the address of a reference. Current usage: C# address of expression

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Addressed reference.

Represents an operation that tests if a value matches a specific pattern. Current usage: C# is pattern expression. For example, x is int i

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Underlying operation to test.

Pattern.

Represents an or operation. Note that this operation is different from an as it mutates the , while unary operator expression does not mutate it's operand. Current usage: C# increment expression or decrement expression

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

if this is a postfix expression. if this is a prefix expression.

if this is a 'lifted' increment operator. When there is an operator that is defined to work on a value type, 'lifted' operators are created to work on the versions of those value types.

if overflow checking is performed for the arithmetic operation.

Target of the assignment.

Operator method used by the operation, null if the operation does not use an operator method.

Type parameter which runtime type will be used to resolve virtual invocation of the , if any. Null if is resolved statically, or is null.

Represents an operation to throw an exception. Current usage: C# throw expression C# throw statement VB Throw statement

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Instance of an exception being thrown.

Represents a assignment with a deconstruction. Current usage: C# deconstruction assignment expression

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Represents a declaration expression operation. Unlike a regular variable declaration and , this operation represents an "expression" declaring a variable. Current usage: C# deconstruction assignment expression. For example: var (x, y) is a deconstruction declaration expression with variables x and y (var x, var y) is a tuple expression with two declaration expressions M(out var x); is an invocation expression with an out var x declaration expression

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Underlying expression.

Represents an argument value that has been omitted in an invocation. Current usage: VB omitted argument in an invocation expression

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Represents an initializer for a field, property, parameter or a local variable declaration. Current usage: C# field, property, parameter or local variable initializer VB field(s), property, parameter or local variable initializer

This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Local declared in and scoped to the .

Underlying initializer value.

Represents an initialization of a field. Current usage: C# field initializer with equals value clause VB field(s) initializer with equals value clause or AsNew clause. Multiple fields can be initialized with AsNew clause in VB

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Initialized fields. There can be multiple fields for Visual Basic fields declared with AsNew clause.

Represents an initialization of a local variable. Current usage: C# local variable initializer with equals value clause VB local variable initializer with equals value clause or AsNew clause

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Represents an initialization of a property. Current usage: C# property initializer with equals value clause VB property initializer with equals value clause or AsNew clause. Multiple properties can be initialized with 'WithEvents' declaration with AsNew clause in VB

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Initialized properties. There can be multiple properties for Visual Basic 'WithEvents' declaration with AsNew clause.

Represents an initialization of a parameter at the point of declaration. Current usage: C# parameter initializer with equals value clause VB parameter initializer with equals value clause

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Initialized parameter.

Represents the initialization of an array instance. Current usage: C# array initializer VB array initializer

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Values to initialize array elements.

Represents a single variable declarator and initializer. Current Usage: C# variable declarator C# catch variable declaration VB single variable declaration VB catch variable declaration

In VB, the initializer for this node is only ever used for explicit array bounds initializers. This node corresponds to the VariableDeclaratorSyntax in C# and the ModifiedIdentifierSyntax in VB. This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Symbol declared by this variable declaration

Optional initializer of the variable.

If this variable is in an , the initializer may be located in the parent operation. Call to check in all locations. It is only possible to have initializers in both locations in VB invalid code scenarios.

Additional arguments supplied to the declarator in error cases, ignored by the compiler. This only used for the C# case of DeclaredArgumentSyntax nodes on a VariableDeclaratorSyntax.

Represents a declarator that declares multiple individual variables. Current Usage: C# VariableDeclaration C# fixed declarations VB Dim statement declaration groups VB Using statement variable declarations

The initializer of this node is applied to all individual declarations in . There cannot be initializers in both locations except in invalid code scenarios. In C#, this node will never have an initializer. This corresponds to the VariableDeclarationSyntax in C#, and the VariableDeclaratorSyntax in Visual Basic. This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Individual variable declarations declared by this multiple declaration.

All will have at least 1 , even if the declaration group only declares 1 variable.

Optional initializer of the variable.

In C#, this will always be null.

Array dimensions supplied to an array declaration in error cases, ignored by the compiler. This is only used for the C# case of RankSpecifierSyntax nodes on an ArrayTypeSyntax.

Represents an argument to a method invocation. Current usage: C# argument to an invocation expression, object creation expression, etc. VB argument to an invocation expression, object creation expression, etc.

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Kind of argument.

Parameter the argument matches. This can be null for __arglist parameters.

Value supplied for the argument.

Information of the conversion applied to the argument value passing it into the target method. Applicable only to VB Reference arguments.

Information of the conversion applied to the argument value after the invocation. Applicable only to VB Reference arguments.

Represents a catch clause. Current usage: C# catch clause VB Catch clause

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Optional source for exception. This could be any of the following operation: 1. Declaration for the local catch variable bound to the caught exception (C# and VB) OR 2. Null, indicating no declaration or expression (C# and VB) 3. Reference to an existing local or parameter (VB) OR 4. Other expression for error scenarios (VB)

Type of the exception handled by the catch clause.

Locals declared by the and/or clause.

Filter operation to be executed to determine whether to handle the exception.

Body of the exception handler.

Represents a switch case section with one or more case clauses to match and one or more operations to execute within the section. Current usage: C# switch section for one or more case clause and set of statements to execute VB case block with a case statement for one or more case clause and set of statements to execute

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Clauses of the case.

One or more operations to execute within the switch section.

Locals declared within the switch case section scoped to the section.

Represents a case clause. Current usage: C# case clause VB Case clause

This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Kind of the clause.

Label associated with the case clause, if any.

Represents a default case clause. Current usage: C# default clause VB Case Else clause

This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Represents a case clause with a pattern and an optional guard operation. Current usage: (1) C# pattern case clause.

This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Label associated with the case clause.

Pattern associated with case clause.

Guard associated with the pattern case clause.

Represents a case clause with range of values for comparison. Current usage: VB range case clause of the form Case x To y

This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Minimum value of the case range.

Maximum value of the case range.

Represents a case clause with custom relational operator for comparison. Current usage: VB relational case clause of the form Case Is op x

This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Case value.

Relational operator used to compare the switch value with the case value.

Represents a case clause with a single value for comparison. Current usage: C# case clause of the form case x VB case clause of the form Case x

This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Case value.

Represents a constituent part of an interpolated string. Current usage: C# interpolated string content VB interpolated string content

This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Represents a constituent string literal part of an interpolated string operation. Current usage: C# interpolated string text VB interpolated string text

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Text content.

Represents a constituent interpolation part of an interpolated string operation. Current usage: C# interpolation part VB interpolation part

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Expression of the interpolation.

Optional alignment of the interpolation.

Optional format string of the interpolation.

Represents a pattern matching operation. Current usage: C# pattern

This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

The input type to the pattern-matching operation.

The narrowed type of the pattern-matching operation.

Represents a pattern with a constant value. Current usage: C# constant pattern

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Constant value of the pattern operation.

Represents a pattern that declares a symbol. Current usage: C# declaration pattern

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

The type explicitly specified, or null if it was inferred (e.g. using in C#).

True if the pattern is of a form that accepts null. For example, in C# the pattern `var x` will match a null input, while the pattern `string x` will not.

Symbol declared by the pattern, if any.

Represents a comparison of two operands that returns a bool type. Current usage: C# tuple binary operator expression

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Kind of binary operation.

Left operand.

Right operand.

Represents a method body operation. Current usage: C# method body

This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Method body corresponding to BaseMethodDeclarationSyntax.Body or AccessorDeclarationSyntax.Body

Method body corresponding to BaseMethodDeclarationSyntax.ExpressionBody or AccessorDeclarationSyntax.ExpressionBody

Represents a method body operation. Current usage: C# method body for non-constructor

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Represents a constructor method body operation. Current usage: C# method body for constructor declaration

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Local declarations contained within the .

Constructor initializer, if any.

Represents a discard operation. Current usage: C# discard expressions

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

The symbol of the discard operation.

Represents a coalesce assignment operation with a target and a conditionally-evaluated value: is evaluated for null. If it is null, is evaluated and assigned to target is conditionally evaluated if is null, and the result is assigned into The result of the entire expression is , which is only evaluated once. Current usage: C# null-coalescing assignment operation Target ??= Value

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Represents a range operation. Current usage: C# range expressions

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Left operand.

Right operand.

if this is a 'lifted' range operation. When there is an operator that is defined to work on a value type, 'lifted' operators are created to work on the versions of those value types.

Factory method used to create this Range value. Can be null if appropriate symbol was not found.

Represents the ReDim operation to re-allocate storage space for array variables. Current usage: VB ReDim statement

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Individual clauses of the ReDim operation.

Modifier used to preserve the data in the existing array when you change the size of only the last dimension.

Represents an individual clause of an to re-allocate storage space for a single array variable. Current usage: VB ReDim clause

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Operand whose storage space needs to be re-allocated.

Sizes of the dimensions of the created array instance.

Represents a C# recursive pattern.

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

The type accepted for the recursive pattern.

The symbol, if any, used for the fetching values for subpatterns. This is either a Deconstruct method, the type System.Runtime.CompilerServices.ITuple, or null (for example, in error cases or when matching a tuple type).

This contains the patterns contained within a deconstruction or positional subpattern.

This contains the (symbol, property) pairs within a property subpattern.

Symbol declared by the pattern.

Represents a discard pattern. Current usage: C# discard pattern

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Represents a switch expression. Current usage: C# switch expression

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Value to be switched upon.

Arms of the switch expression.

True if the switch expressions arms cover every possible input value.

Represents one arm of a switch expression.

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

The pattern to match.

Guard (when clause expression) associated with the switch arm, if any.

Result value of the enclosing switch expression when this arm matches.

Locals declared within the switch arm (e.g. pattern locals and locals declared in the guard) scoped to the arm.

Represents an element of a property subpattern, which identifies a member to be matched and the pattern to match it against.

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

The member being matched in a property subpattern. This can be a in non-error cases, or an in error cases.

The pattern to which the member is matched in a property subpattern.

Represents a standalone VB query Aggregate operation with more than one item in Into clause.

This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Represents a C# fixed statement.

This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Locals declared.

Variables to be fixed.

Body of the fixed, over which the variables are fixed.

Represents a creation of an instance of a NoPia interface, i.e. new I(), where I is an embedded NoPia interface. Current usage: C# NoPia interface instance creation expression VB NoPia interface instance creation expression

This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Object or collection initializer, if any.

Represents a general placeholder when no more specific kind of placeholder is available. A placeholder is an expression whose meaning is inferred from context.

This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Represents a reference through a pointer. Current usage: C# pointer indirection reference expression

This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Pointer to be dereferenced.

Represents a of operations that are executed with implicit reference to the for member references. Current usage: VB With statement

This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Body of the with.

Value to whose members leading-dot-qualified references within the with body bind.

Represents using variable declaration, with scope spanning across the parent . Current Usage: C# using declaration C# asynchronous using declaration

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

The variables declared by this using declaration.

True if this is an asynchronous using declaration.

Represents a negated pattern. Current usage: C# negated pattern

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

The negated pattern.

Represents a binary ("and" or "or") pattern. Current usage: C# "and" and "or" patterns

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Kind of binary pattern; either or .

The pattern on the left.

The pattern on the right.

Represents a pattern comparing the input with a given type. Current usage: C# type pattern

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

The type explicitly specified, or null if it was inferred (e.g. using in C#).

Represents a pattern comparing the input with a constant value using a relational operator. Current usage: C# relational pattern

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

The kind of the relational operator.

Constant value of the pattern operation.

Represents cloning of an object instance. Current usage: C# with expression

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Operand to be cloned.

Clone method to be invoked on the value. This can be null in error scenarios.

With collection initializer.

Represents an interpolated string converted to a custom interpolated string handler type.

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

The construction of the interpolated string handler instance. This can be an for valid code, and or for invalid code.

True if the last parameter of is an out parameter that will be checked before executing the code in . False otherwise.

True if the AppendLiteral or AppendFormatted calls in nested return . When that is true, each part will be conditional on the return of the part before it, only being executed when the Append call returns true. False otherwise.

when this is true and is true, then the first part in nested is conditionally run. If this is true and is false, then the first part is unconditionally run.
Just because this is true or false does not guarantee that all Append calls actually do return boolean values, as there could be dynamic calls or errors. It only governs what the compiler was expecting, based on the first calls it did see.

The interpolated string expression or addition operation that makes up the content of this string. This is either an or an operation.

Represents an addition of multiple interpolated string literals being converted to an interpolated string handler type.

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

The interpolated string expression or addition operation on the left side of the operator. This is either an or an operation.

The interpolated string expression or addition operation on the right side of the operator. This is either an or an operation.

Represents a call to either AppendLiteral or AppendFormatted as part of an interpolated string handler conversion.

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

If this interpolated string is subject to an interpolated string handler conversion, the construction of the interpolated string handler instance. This can be an or for valid code, and for invalid code.

Represents an argument from the method call, indexer access, or constructor invocation that is creating the containing

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

The index of the argument of the method call, indexer, or object creation containing the interpolated string handler conversion this placeholder is referencing. -1 if is anything other than .

The component this placeholder represents.

Represents an invocation of a function pointer.

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Invoked pointer.

Arguments of the invocation. Arguments are in evaluation order.

Represents a C# list pattern.

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

The Length or Count property that is used to fetch the length value. Returns null if no such property is found.

The indexer that is used to fetch elements. Returns null for an array input.

Returns subpatterns contained within the list pattern.

Symbol declared by the pattern, if any.

Represents a C# slice pattern.

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

The range indexer or the Slice method used to fetch the slice value.

The pattern that the slice value is matched with, if any.

Represents a reference to an implicit System.Index or System.Range indexer over a non-array type. Current usage: C# implicit System.Index or System.Range indexer reference expression

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Instance of the type to be indexed.

System.Index or System.Range value.

The Length or Count property that might be used to fetch the length value.

Symbol for the underlying indexer or a slice method that is used to implement the implicit indexer.

Represents a UTF-8 encoded byte representation of a string. Current usage: C# UTF-8 string literal expression

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

The underlying string value.

Represents the application of an attribute. Current usage: C# attribute application VB attribute application

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

The operation representing the attribute. This can be a in non-error cases, or an in error cases.

Represents an element reference or a slice operation over an inline array type. Current usage: C# inline array access

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Instance of the inline array type to be accessed.

System.Int32, System.Index or System.Range value.

Represents a collection expression. Current usage: C# collection expression

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Method used to construct the collection. If the collection type is an array, span, array interface, or type parameter, the method is null; if the collection type has a [CollectionBuilder] attribute, the method is the builder method; otherwise, the method is the collection type constructor.

Collection expression elements. If the element is an expression, the entry is the expression, with a conversion to the target element type if necessary; otherwise, the entry is an ISpreadOperation.

Represents a collection expression spread element. Current usage: C# spread element

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Collection being spread.

Type of the elements in the collection.

Conversion from the type of the collection element to the target element type of the containing collection expression.

This creates a block that can be used for temporary, internal applications that require a block composed of statements from another block. Blocks created by this API violate IOperation tree constraints and should never be exposed from a public API.

Deep clone given IOperation

Represents a visitor that visits only the single IOperation passed into its Visit method.

Represents a visitor that visits only the single IOperation passed into its Visit method with an additional argument of the type specified by the parameter and produces a value of the type specified by the parameter.

The type of the additional argument passed to this visitor's Visit method. The type of the return value of this visitor's Visit method.

Kinds of arguments.

Represents unknown argument kind.

Argument value is explicitly supplied.

Argument is a param array created by compilers for the matching C# params or VB ParamArray parameter. Note, the value is an array creation expression that encapsulates all the elements, if any.

Argument is a default value supplied automatically by the compilers.

Argument is a param collection created by compilers for the matching C# params parameter. Note, the value is a collection expression that encapsulates all the elements, if any.

Kind of binary operator.

Represents unknown or error operator kind.

Represents the '+' operator.

Represents the '-' operator.

Represents the '*' operator.

Represents the '/' operator.

Represents the VB '\' integer divide operator.

Represents the C# '%' operator and VB 'Mod' operator.

Represents the VB '^' exponentiation operator.

Represents the operator.

Represents the >']]> operator.

Represents the C# operator and VB 'And' operator.

Represents the C# operator and VB 'Or' operator.

Represents the C# '^' operator and VB 'Xor' operator.

Represents the C# operator and VB 'AndAlso' operator.

Represents the C# operator and VB 'OrElse' operator.

Represents the VB operator for string concatenation.

Represents the C# '==' operator and VB 'Is' operator and '=' operator for non-object typed operands.

Represents the VB '=' operator for object typed operands.

Represents the C# '!=' operator and VB 'IsNot' operator and ']]> operator for non-object typed operands.

Represents the VB ']]> operator for object typed operands.

Represents the operator.

Represents the =']]> operator.

Represents the ']]> operator.

Represents the VB 'Like' operator.

Represents the >>']]> operator.

Kind of the branch for an

Represents unknown branch kind.

Represents a continue branch kind.

Represents a break branch kind.

Represents a goto branch kind.

Kinds of cases.

Represents unknown case kind.

Indicates an in C# or VB.

Indicates an in VB.

Indicates an in C# or VB.

Indicates an in C#.

Represents the common, language-agnostic elements of a conversion.

We reserve the right to change this struct in the future.

Returns true if the conversion exists, as defined by the target language.

The existence of a conversion does not necessarily imply that the conversion is valid. For example, an ambiguous user-defined conversion may exist but may not be valid.

Returns true if the conversion is an identity conversion.

Returns true if the conversion is an nullable conversion.

Returns true if the conversion is a numeric conversion.

Returns true if the conversion is a reference conversion.

Returns true if the conversion is an implicit (C#) or widening (VB) conversion.

Returns true if the conversion is a user-defined conversion.

Returns the method used to perform the conversion for a user-defined conversion if is true. Otherwise, returns null.

Type parameter which runtime type will be used to resolve virtual invocation of the , if any. Null if is resolved statically, or is null.

Kind of reference for an .

Reference to an instance of the containing type. Used for this and base in C# code, and Me, MyClass, MyBase in VB code.

Reference to the object being initialized in C# or VB object or collection initializer, anonymous type creation initializer, or to the object being referred to in a VB With statement, or the C# 'with' expression initializer.

Reference to the value being matching in a property subpattern.

Reference to the interpolated string handler instance created as part of a parent interpolated string handler conversion.

Kind of placeholder for an .

This is a placeholder for an argument from the containing method call, indexer access, or object creation. The corresponding argument index is accessed in .

This is a placeholder for the receiver of the containing method call, indexer access, or object creation.

This is a placeholder for the trailing bool out parameter of the interpolated string handler type. This bool controls whether the conditional evaluation for the rest of the interpolated string should be run after the constructor returns.

Element type of the collection

The conversion from the type of the to the .

The conversion from the to the iteration variable type.

Kinds of loop operations.

Represents unknown loop kind.

Represents an in C# or VB.

Indicates an in C#.

Indicates an in VB.

Indicates an in C# or VB.

Helper function to simplify the access to the function pointer signature of an FunctionPointerInvocationOperation

This will check whether context around the operation has any error such as syntax or semantic error

Returns all the descendant operations of the given in evaluation order.

Operation whose descendants are to be fetched.

Returns all the descendant operations of the given including the given in evaluation order.

Operation whose descendants are to be fetched.

Gets all the declared local variables in the given .

Variable declaration group

Gets all the declared local variables in the given .

Variable declaration

Gets the variable initializer for the given , checking to see if there is a parent initializer if the single variable initializer is null.

Single variable declaration to retrieve initializer for.

Get an optional argument name for a named argument to the given at the given .

Dynamic or late bound operation. Argument index.

Get an optional argument name for a named argument to the given at the given .

Dynamic or late bound operation. Argument index.

Get an optional argument name for a named argument to the given at the given .

Dynamic or late bound operation. Argument index.

Get an optional argument name for a named argument to the given at the given .

Dynamic or late bound operation. Argument index.

Get an optional argument for an argument at the given to the given . Returns a non-null argument for C#. Always returns null for VB as cannot be specified for an argument in VB.

Dynamic or late bound operation. Argument index.

Get an optional argument for an argument at the given to the given . Returns a non-null argument for C#. Always returns null for VB as cannot be specified for an argument in VB.

Dynamic or late bound operation. Argument index.

Get an optional argument for an argument at the given to the given . Returns a non-null argument for C#. Always returns null for VB as cannot be specified for an argument in VB.

Dynamic or late bound operation. Argument index.

Gets the root operation for the tree containing the given .

Operation whose root is requested.

Gets either a loop or a switch operation that corresponds to the given branch operation.

The branch operation for which a corresponding operation is looked up The corresponding operation or null in case not found (e.g. no loop or switch syntax, or the branch is not a break or continue) is null The operation is a part of Control Flow Graph

Use this to create IOperation when we don't have proper specific IOperation yet for given language construct

Represents a that descends an entire tree visiting each IOperation and its child IOperation nodes in depth-first order.

Represents a that descends an entire tree visiting each IOperation and its child IOperation nodes in depth-first order. Returns null.

Kind of unary operator

Represents unknown or error operator kind.

Represents the C# '~' operator.

Represents the C# '!' operator and VB 'Not' operator.

Represents the unary '+' operator.

Represents the unary '-' operator.

Represents the C# 'true' operator and VB 'IsTrue' operator.

Represents the C# 'false' operator and VB 'IsFalse' operator.

Represents the C# '^' operator.

Gets symbol information about a syntax node.

The syntax node to get semantic information for. A cancellation token that can be used to cancel the process of obtaining the semantic info.

Binds the node in the context of the specified location and get semantic information such as type, symbols and diagnostics. This method is used to get semantic information about an expression that did not actually appear in the source code.

A character position used to identify a declaration scope and accessibility. This character position must be within the FullSpan of the Root syntax node in this SemanticModel. A syntax node that represents a parsed expression. This syntax node need not and typically does not appear in the source code referred to SemanticModel instance. Indicates whether to binding the expression as a full expressions, or as a type or namespace. If SpeculativeBindingOption.BindAsTypeOrNamespace is supplied, then expression should derive from TypeSyntax. The semantic information for the topmost node of the expression. The passed in expression is interpreted as a stand-alone expression, as if it appeared by itself somewhere within the scope that encloses "position".

Gets type information about a syntax node.

The syntax node to get semantic information for. A cancellation token that can be used to cancel the process of obtaining the semantic info.

If "nameSyntax" resolves to an alias name, return the IAliasSymbol corresponding to A. Otherwise return null.

Name to get alias info for. A cancellation token that can be used to cancel the process of obtaining the alias information.

Binds the name in the context of the specified location and sees if it resolves to an alias name. If it does, return the AliasSymbol corresponding to it. Otherwise, return null.

A character position used to identify a declaration scope and accessibility. This character position must be within the FullSpan of the Root syntax node in this SemanticModel. A syntax node that represents a name. This syntax node need not and typically does not appear in the source code referred to by the SemanticModel instance. Indicates whether to binding the name as a full expression, or as a type or namespace. If SpeculativeBindingOption.BindAsTypeOrNamespace is supplied, then expression should derive from TypeSyntax. The passed in name is interpreted as a stand-alone name, as if it appeared by itself somewhere within the scope that encloses "position".

Gets the symbol associated with a declaration syntax node.

A syntax node that is a declaration. This can be any type derived from MemberDeclarationSyntax, TypeDeclarationSyntax, EnumDeclarationSyntax, NamespaceDeclarationSyntax, ParameterSyntax, TypeParameterSyntax, or the alias part of a UsingDirectiveSyntax The cancellation token. The symbol declared by the node or null if the node is not a declaration.

Gets a list of method or indexed property symbols for a syntax node.

The syntax node to get semantic information for. The cancellation token.

Analyze control-flow within a part of a method body.

Analyze data-flow within a part of a method body.

Analyze data-flow within a part of a method body. note (for C#): ConstructorInitializerSyntax and PrimaryConstructorBaseTypeSyntax are treated by this API as regular statements

It is unknown if the is automatically generated.

The is not automatically generated.

The is marked as automatically generated.

Represents the set of symbols that are imported to a particular position in a source file. Each import has a reference to the location the import directive was declared at. For the import, the location can be found using either or on the itself. For or the location is found through or respectively.

Scopes returned will always have at least one non-empty property value in them. Symbols may be imported, but may not necessarily be available at that location (for example, an alias symbol hidden by another symbol). In C# there will be an for every containing namespace-declarations that include any import directives. There will also be an for the containing compilation-unit if it includes any import directives or if there are global import directives pulled in from other files. In Visual Basic there will commonly be one or two s returned for any position. This will commonly be a scope for the containing compilation unit if it includes any import directives. As well as a scope representing any imports specified at the project level. Elements of any property have no defined order. Even if they represent items from a single document, they are not guaranteed to be returned in any specific file-oriented order. There is no guarantee that the same scope instances will be returned from successive calls to .

Aliases defined at this level of the chain. This corresponds to using X = TypeOrNamespace; in C# or Imports X = TypeOrNamespace in Visual Basic. This will include global aliases if present for both languages.

May be , will never be .

Extern aliases defined at this level of the chain. This corresponds to extern alias X; in C#. It will be empty in Visual Basic.

May be , will never be .

Types or namespaces imported at this level of the chain. This corresponds to using Namespace; or using static Type; in C#, or Imports TypeOrNamespace in Visual Basic. This will include global namespace or type imports for both languages.

May be , will never be .

Xml namespaces imported at this level of the chain. This corresponds to Imports <xmlns:prefix = "name"> in Visual Basic. It will be empty in C#.

May be , will never be .

Represents an that has been imported, and the location the import was declared at. This corresponds to using Namespace; or using static Type; in C#, or Imports TypeOrNamespace in Visual Basic.

Location in source where the using directive or Imports clause was declared. May be null for Visual Basic for a project-level import directive, or for a C# global using provided directly through .

Represents an imported xml namespace name. This corresponds to Imports <xmlns:prefix = "name"> in Visual Basic. It does not exist for C#.

Location in source where the Imports clause was declared. May be null for a project-level import directive.

Simple POCO implementation of the import scope, usable by both C# and VB.

Represents the state of the nullable analysis at a specific point in a file. Bits one and two correspond to whether the nullable feature is enabled. Bits three and four correspond to whether the context was inherited from the global context.

Nullable warnings and annotations are explicitly turned off at this location.

Nullable warnings are enabled and will be reported at this file location.

Nullable annotations are enabled and will be shown when APIs defined at this location are used in other contexts.

The nullable feature is fully enabled.

The nullable warning state is inherited from the project default. The project default can change depending on the file type. Generated files have nullable off by default, regardless of the project-level default setting.

The nullable annotation state is inherited from the project default. The project default can change depending on the file type. Generated files have nullable off by default, regardless of the project-level default setting.

The current state of both warnings and annotations are inherited from the project default. This flag is set by default at the start of all files. The project default can change depending on the file type. Generated files have nullable off by default, regardless of the project-level default setting.

Returns whether nullable warnings are enabled for this context.

Returns whether nullable annotations are enabled for this context.

Returns whether the nullable warning state was inherited from the project default for this file type.

Returns whether the nullable annotation state was inherited from the project default for this file type.

Represents the default state of nullable analysis in this compilation.

The nullable analysis feature is disabled.

Nullable warnings are enabled and will be reported by default.

Nullable annotations are enabled and will be shown when APIs defined in this project are used in other contexts.

The nullable analysis feature is fully enabled.

Returns whether nullable warnings are enabled.

Returns whether nullable annotations are enabled.

Determines the level of optimization of the generated code.

Disables all optimizations and instruments the generated code to improve debugging experience. The compiler prefers debuggability over performance. Do not use for code running in a production environment. JIT optimizations are disabled via assembly level attribute (). Edit and Continue is enabled. Slots for local variables are not reused, lifetime of local variables is extended to make the values available during debugging. Corresponds to command line argument /optimize-.

Enables all optimizations, debugging experience might be degraded. The compiler prefers performance over debuggability. Use for code running in a production environment. JIT optimizations are enabled via assembly level attribute (). Edit and Continue is disabled. Sequence points may be optimized away. As a result it might not be possible to place or hit a breakpoint. User-defined locals might be optimized away. They might not be available while debugging. Corresponds to command line argument /optimize+.

Represents parse options common to C# and VB.

Specifies whether to parse as regular code files, script files or interactive code.

Gets the specified source code kind, which is the value that was specified in the call to the constructor, or modified using the method.

Gets a value indicating whether the documentation comments are parsed and analyzed.

Gets the source language ("C#" or "Visual Basic").

Errors collection related to an incompatible set of parse options

Creates a new options instance with the specified source code kind.

Performs validation of options compatibilities and generates diagnostics if needed

Creates a new options instance with the specified documentation mode.

Enable some experimental language features for testing.

Returns the experimental features.

Names of defined preprocessor symbols.

AnyCPU (default) compiles the assembly to run on any platform.

x86 compiles the assembly to be run by the 32-bit, x86-compatible common language runtime.

x64 compiles the assembly to be run by the 64-bit common language runtime on a computer that supports the AMD64 or EM64T instruction set.

Itanium compiles the assembly to be run by the 64-bit common language runtime on a computer with an Itanium processor.

Compiles your assembly to run on any platform. Your application runs in 32-bit mode on systems that support both 64-bit and 32-bit applications.

Compiles your assembly to run on a computer that has an Advanced RISC Machine (ARM) processor.

Compiles your assembly to run on a computer that has an Advanced RISC Machine 64 bit (ARM64) processor.

The symbol that was referred to by the identifier, if any.

Returns true if this preprocessing symbol is defined at the identifier position.

This represents the set of document names for the #line / #ExternalSource directives that we need to emit into the PDB (in the order specified in the array).

Allows asking semantic questions about a tree of syntax nodes in a Compilation. Typically, an instance is obtained by a call to .

An instance of SemanticModel caches local symbols and semantic information. Thus, it is much more efficient to use a single instance of SemanticModel when asking multiple questions about a syntax tree, because information from the first question may be reused. This also means that holding onto an instance of SemanticModel for a long time may keep a significant amount of memory from being garbage collected. When an answer is a named symbol that is reachable by traversing from the root of the symbol table, (that is, from an AssemblySymbol of the Compilation), that symbol will be returned (i.e. the returned value will be reference-equal to one reachable from the root of the symbol table). Symbols representing entities without names (e.g. array-of-int) may or may not exhibit reference equality. However, some named symbols (such as local variables) are not reachable from the root. These symbols are visible as answers to semantic questions. When the same SemanticModel object is used, the answers exhibit reference-equality.

Gets the source language ("C#" or "Visual Basic").

The compilation this model was obtained from.

The syntax tree this model was obtained from.

Gets the operation corresponding to the expression or statement syntax node.

The expression or statement syntax node. An optional cancellation token.

Returns true if this is a SemanticModel that ignores accessibility rules when answering semantic questions.

Gets symbol information about a syntax node.

The syntax node to get semantic information for. A cancellation token that can be used to cancel the process of obtaining the semantic info.

Gets symbol information about a syntax node.

The syntax node to get semantic information for. A cancellation token that can be used to cancel the process of obtaining the semantic info.

Gets type information about a syntax node.

The syntax node to get semantic information for. A cancellation token that can be used to cancel the process of obtaining the semantic info.

Gets type information about a syntax node.

The syntax node to get semantic information for. A cancellation token that can be used to cancel the process of obtaining the semantic info.

If "nameSyntax" resolves to an alias name, return the IAliasSymbol corresponding to A. Otherwise return null.

Name to get alias info for. A cancellation token that can be used to cancel the process of obtaining the alias information.

If "nameSyntax" resolves to an alias name, return the IAliasSymbol corresponding to A. Otherwise return null.

Name to get alias info for. A cancellation token that can be used to cancel the process of obtaining the alias information.

Returns true if this is a speculative semantic model created with any of the TryGetSpeculativeSemanticModel methods.

If this is a speculative semantic model, returns the original position at which the speculative model was created. Otherwise, returns 0.

If this is a speculative semantic model, then returns its parent semantic model. Otherwise, returns null.

If this is an instance of semantic model that cannot be exposed to external consumers, then returns the containing public semantic model. Otherwise, returns this instance of the semantic model.

Binds the name in the context of the specified location and sees if it resolves to an alias name. If it does, return the AliasSymbol corresponding to it. Otherwise, return null.

A character position used to identify a declaration scope and accessibility. This character position must be within the FullSpan of the Root syntax node in this SemanticModel. A syntax node that represents a name. This syntax node need not and typically does not appear in the source code referred to by the SemanticModel instance. Indicates whether to binding the name as a full expression, or as a type or namespace. If SpeculativeBindingOption.BindAsTypeOrNamespace is supplied, then expression should derive from TypeSyntax. The passed in name is interpreted as a stand-alone name, as if it appeared by itself somewhere within the scope that encloses "position".

Binds the name in the context of the specified location and sees if it resolves to an alias name. If it does, return the AliasSymbol corresponding to it. Otherwise, return null.

A character position used to identify a declaration scope and accessibility. This character position must be within the FullSpan of the Root syntax node in this SemanticModel. A syntax node that represents a name. This syntax node need not and typically does not appear in the source code referred to by the SemanticModel instance. Indicates whether to binding the name as a full expression, or as a type or namespace. If SpeculativeBindingOption.BindAsTypeOrNamespace is supplied, then expression should derive from TypeSyntax. The passed in name is interpreted as a stand-alone name, as if it appeared by itself somewhere within the scope that encloses "position".

Get all of the syntax errors within the syntax tree associated with this object. Does not get errors involving declarations or compiling method bodies or initializers.

Get all of the declaration errors within the syntax tree associated with this object. Does not get errors involving incorrect syntax, compiling method bodies or initializers.

Optional span within the syntax tree for which to get diagnostics. If no argument is specified, then diagnostics for the entire tree are returned. A cancellation token that can be used to cancel the process of obtaining the diagnostics. The declaration errors for a syntax tree are cached. The first time this method is called, all declarations are analyzed for diagnostics. Calling this a second time will return the cached diagnostics.

Get all of the method body and initializer errors within the syntax tree associated with this object. Does not get errors involving incorrect syntax or declarations.

Optional span within the syntax tree for which to get diagnostics. If no argument is specified, then diagnostics for the entire tree are returned. A cancellation token that can be used to cancel the process of obtaining the diagnostics. The method body errors for a syntax tree are not cached. The first time this method is called, all method bodies are analyzed for diagnostics. Calling this a second time will repeat this work.

Get all the errors within the syntax tree associated with this object. Includes errors involving compiling method bodies or initializers, in addition to the errors returned by GetDeclarationDiagnostics.

Optional span within the syntax tree for which to get diagnostics. If no argument is specified, then diagnostics for the entire tree are returned. A cancellation token that can be used to cancel the process of obtaining the diagnostics. Because this method must semantically bind all method bodies and initializers to check for diagnostics, it may take a significant amount of time. Unlike GetDeclarationDiagnostics, diagnostics for method bodies and initializers are not cached, any semantic information used to obtain the diagnostics is discarded.

Gets the symbol associated with a declaration syntax node.

Gets the symbols associated with a declaration syntax node. Unlike , this method returns all symbols declared by a given declaration syntax node. Specifically: in the case of field declaration syntax nodes, which can declare multiple symbols, this method returns all declared symbols. in the case of type declarations with a primary constructor, both the for the type, and the for the primary constructor will be returned.

Gets the available named symbols in the context of the specified location and optional container. Only symbols that are accessible and visible from the given location are returned.

The character position for determining the enclosing declaration scope and accessibility. The container to search for symbols within. If null then the enclosing declaration scope around position is used. The name of the symbol to find. If null is specified then symbols with any names are returned. Consider (reduced) extension methods. A list of symbols that were found. If no symbols were found, an empty list is returned. The "position" is used to determine what variables are visible and accessible. Even if "container" is specified, the "position" location is significant for determining which members of "containing" are accessible. Labels are not considered (see ). Non-reduced extension methods are considered regardless of the value of .

Backing implementation of .

Gets the available base type members in the context of the specified location. Akin to calling with the container set to the immediate base type of the type in which occurs. However, the accessibility rules are different: protected members of the base type will be visible. Consider the following example: public class Base { protected void M() { } } public class Derived : Base { void Test(Base b) { b.M(); // Error - cannot access protected member. base.M(); } } Protected members of an instance of another type are only accessible if the instance is known to be "this" instance (as indicated by the "base" keyword).

The character position for determining the enclosing declaration scope and accessibility. The name of the symbol to find. If null is specified then symbols with any names are returned. A list of symbols that were found. If no symbols were found, an empty list is returned. The "position" is used to determine what variables are visible and accessible. Non-reduced extension methods are considered, but reduced extension methods are not.

Backing implementation of .

Gets the available named static member symbols in the context of the specified location and optional container. Only members that are accessible and visible from the given location are returned. Non-reduced extension methods are considered, since they are static methods.

The character position for determining the enclosing declaration scope and accessibility. The container to search for symbols within. If null then the enclosing declaration scope around position is used. The name of the symbol to find. If null is specified then symbols with any names are returned. A list of symbols that were found. If no symbols were found, an empty list is returned. The "position" is used to determine what variables are visible and accessible. Even if "container" is specified, the "position" location is significant for determining which members of "containing" are accessible. Essentially the same as filtering instance members out of the results of an analogous call.

Backing implementation of .

Gets the available named namespace and type symbols in the context of the specified location and optional container. Only members that are accessible and visible from the given location are returned.

The character position for determining the enclosing declaration scope and accessibility. The container to search for symbols within. If null then the enclosing declaration scope around position is used. The name of the symbol to find. If null is specified then symbols with any names are returned. A list of symbols that were found. If no symbols were found, an empty list is returned. The "position" is used to determine what variables are visible and accessible. Even if "container" is specified, the "position" location is significant for determining which members of "containing" are accessible. Does not return INamespaceOrTypeSymbol, because there could be aliases.

Backing implementation of .

Gets the available named label symbols in the context of the specified location and optional container. Only members that are accessible and visible from the given location are returned.

The character position for determining the enclosing declaration scope and accessibility. The name of the symbol to find. If null is specified then symbols with any names are returned. A list of symbols that were found. If no symbols were found, an empty list is returned. The "position" is used to determine what variables are visible and accessible. Even if "container" is specified, the "position" location is significant for determining which members of "containing" are accessible.

Backing implementation of .

Analyze control-flow within a part of a method body.

The first node to be included within the analysis. The last node to be included within the analysis. An object that can be used to obtain the result of the control flow analysis. The span is not with a method body. The first and last nodes must be fully inside the same method body.

Analyze control-flow within a part of a method body.

The statement to be analyzed. An object that can be used to obtain the result of the control flow analysis. The span is not with a method body. The statement must be fully inside the same method body.

Analyze control-flow within a part of a method body.

Analyze data-flow within a part of a method body.

The first node to be included within the analysis. The last node to be included within the analysis. An object that can be used to obtain the result of the data flow analysis. The span is not with a method body. The first and last nodes must be fully inside the same method body.

Analyze data-flow within a part of a method body.

The statement or expression to be analyzed. A ConstructorInitializerSyntax / PrimaryConstructorBaseTypeSyntax is treated here as a regular statement. An object that can be used to obtain the result of the data flow analysis. The statement or expression is not with a method body or field or property initializer. The statement or expression must be fully inside a method body.

Analyze data-flow within a part of a method body.

The statement or expression to be analyzed. An object that can be used to obtain the result of the data flow analysis. The statement or expression is not with a method body or field or property initializer. The statement or expression must be fully inside a method body.

If the node provided has a constant value an Optional value will be returned with HasValue set to true and with Value set to the constant. If the node does not have an constant value, an Optional will be returned with HasValue set to false.

When getting information for a symbol that resolves to a method group or property group, from which a method is then chosen; the chosen method or property is present in Symbol; all methods in the group that was consulted are placed in this property.

Given a position in the SyntaxTree for this SemanticModel returns the innermost Symbol that the position is considered inside of.

Given a position in the SyntaxTree for this SemanticModel returns the s at that point. Scopes are ordered from closest to the passed in to the furthest. See for a deeper description of what information is available for each scope.

Determines if the symbol is accessible from the specified location.

A character position used to identify a declaration scope and accessibility. This character position must be within the FullSpan of the Root syntax node in this SemanticModel. The symbol that we are checking to see if it accessible. True if "symbol is accessible, false otherwise. This method only checks accessibility from the point of view of the accessibility modifiers on symbol and its containing types. Even if true is returned, the given symbol may not be able to be referenced for other reasons, such as name hiding.

Determines if the symbol is accessible from the specified location.

Field-like events can be used as fields in types that can access private members of the declaring type of the event.

Always false for VB events.

Field-like events can be used as fields in types that can access private members of the declaring type of the event.

Always false for VB events.

If is an identifier name syntax node, return the corresponding to it.

The nameSyntax node to get semantic information for.

If is an identifier name syntax node, return the corresponding to it.

The nameSyntax node to get semantic information for.

Gets the for all the declarations whose span overlaps with the given .

Span to get declarations. Flag indicating whether should be computed for the returned declaration infos. If false, then is always null. Builder to add declarations. Cancellation token.

Takes a node and returns a set of declarations that overlap the node's span.

Gets a filter that determines whether or not a given syntax node and its descendants should be analyzed for the given declared node and declared symbol. We have scenarios where certain syntax nodes declare multiple symbols, for example record declarations, and we want to avoid duplicate syntax node callbacks for such nodes. Note that the predicate returned by this method filters out both the node and all its descendants from analysis. If you wish to skip analysis just for a specific node, but not its descendants, then add the required logic in .

Determines if the given syntax node with the given containing symbol should be analyzed or not. Note that only the given syntax node will be filtered out from analysis, this API will be invoked separately for each of its descendants. If you wish to skip analysis of the node and all its descendants, then add the required logic to .

Takes a Symbol and syntax for one of its declaring syntax reference and returns the topmost syntax node to be used by syntax analyzer.

Root of this semantic model

Gets the at a position in the file.

The position to get the context for.

Provides semantic models for syntax trees in a compilation. This provider can be attached to a compilation, see .

Gets a for the given that belongs to the given .

Resolves references to source documents specified in the source.

Normalizes specified source path with respect to base file path.

The source path to normalize. May be absolute or relative. Path of the source file that contains the (may also be relative), or null if not available. Normalized path, or null if can't be normalized. The resulting path doesn't need to exist.

Resolves specified path with respect to base file path.

The path to resolve. May be absolute or relative. Path of the source file that contains the (may also be relative), or null if not available. Normalized path, or null if the file can't be resolved.

Opens a that allows reading the content of the specified file.

Path returned by . is null. is not a valid absolute path. Error reading file . See for details.

Reads the contents of and returns a .

Path returned by .

Describes the kind of binding to be performed in one of the SemanticModel speculative binding methods.

Binds the given expression using the normal expression binding rules that would occur during normal binding of expressions.

Binds the given expression as a type or namespace only. If this option is selected, then the given expression must derive from TypeSyntax.

Represents subsystem version, see /subsystemversion command line option for details and valid values. The following table lists common subsystem versions of Windows. Windows version Subsystem version - Windows 2000 5.00 - Windows XP 5.01 - Windows Vista 6.00 - Windows 7 6.01 - Windows 8 Release Preview 6.02

Major subsystem version

Minor subsystem version

Subsystem version not specified

Subsystem version: Windows 2000

Subsystem version: Windows XP

Subsystem version: Windows Vista

Subsystem version: Windows 7

Subsystem version: Windows 8

Try parse subsystem version in "x.y" format. Note, no spaces are allowed in string representation.

String to parse the value if successfully parsed or None otherwise true if parsed successfully, false otherwise

Create a new instance of subsystem version with specified major and minor values.

major subsystem version minor subsystem version subsystem version with provided major and minor

Subsystem version default for the specified output kind and platform combination

Output kind Platform Subsystem version

True if the subsystem version has a valid value

Indicate what kinds of declaration symbols will be included

None

include namespace symbols

include type symbols

include member symbols such as method, event, property, field

include type and member

include all namespace, type and member

Array of potential candidate symbols if did not bind successfully. Note: all code in this type should prefer referencing instead of this so that they uniformly only see an non- array.

The symbol that was referred to by the syntax node, if any. Returns null if the given expression did not bind successfully to a single symbol. If null is returned, it may still be that case that we have one or more "best guesses" as to what symbol was intended. These best guesses are available via the property.

If the expression did not successfully resolve to a symbol, but there were one or more symbols that may have been considered but discarded, this property returns those symbols. The reason that the symbols did not successfully resolve to a symbol are available in the property. For example, if the symbol was inaccessible, ambiguous, or used in the wrong context.

Will never return a array.

If the expression did not successfully resolve to a symbol, but there were one or more symbols that may have been considered but discarded, this property describes why those symbol or symbols were not considered suitable.

Get whether the given tree is generated.

Get diagnostic severity setting for a given diagnostic identifier in a given tree.

Get diagnostic severity set globally for a given diagnostic identifier

The type of the expression represented by the syntax node. For expressions that do not have a type, null is returned. If the type could not be determined due to an error, then an IErrorTypeSymbol is returned.

The top-level nullability information of the expression represented by the syntax node.

The type of the expression after it has undergone an implicit conversion. If the type did not undergo an implicit conversion, returns the same as Type.

The top-level nullability of the expression after it has undergone an implicit conversion. For most expressions, this will be the same as the type. It can change in situations such as implicit user-defined conversions that have a nullable return type.

Resolves references to XML documents specified in source code.

Resolves specified XML reference with respect to base file path.

The reference path to resolve. May be absolute or relative path. Path of the source file that contains the (may also be relative), or null if not available. Path to the XML artifact, or null if the file can't be resolved.

Opens a that allows reading the content of the specified file.

Path returned by . is null. is not a valid absolute path. Error reading file . See for details.

The IEEE floating-point spec doesn't specify which bit pattern an implementation is required to use when producing NaN values. Indeed, the spec does recommend "diagnostic" information "left to the implementer’s discretion" be placed in the undefined bits. It is therefore likely that NaNs produced on different platforms will differ even for the same arithmetic such as 0.0 / 0.0. To ensure that the compiler behaves in a deterministic way, we force NaN values to use the IEEE "canonical" form with the diagnostic bits set to zero and the sign bit set to one. Conversion of this value to float produces the corresponding canonical NaN of the float type (IEEE Std 754-2008 section 6.2.3).

Some string constant values can have large costs to realize. To compensate, we realize constant values lazily, and hold onto a weak reference. If the next time we're asked for the constant value the previous one still exists, we can avoid rerealizing it. But we don't want to root the constant value if it's not being used.

Parses .RES a file into its constituent resource elements. Mostly translated from cvtres.cpp.

Assume that 3 WORDs preceded this string and that they began 32-bit aligned. Given the string length compute the number of bytes that should be written to end the buffer on a 32-bit boundary

assuming the length of bytes submitted began on a 32-bit boundary, round up this length as necessary so that it ends at a 32-bit boundary.

compute number of chars needed to end up on a 32-bit boundary assuming that three WORDS preceded this string.

Policy to be used when matching assembly reference to an assembly definition across platforms.

Converts to .

Major, minor, build or revision number are less than 0 or greater than 0xFFFF. Assembly portability policy, usually provided through an app.config file.

Loads information from XML with app.config schema.

The stream doesn't contain a well formed XML. is null. Tries to find supportPortability elements in the given XML: ]]> Keeps the stream open.

Returns true if the identity is a Framework 4.5 or lower assembly.

Represents a non source code file.

Path to the text.

Returns a with the contents of this file, or null if there were errors reading the file.

Provides custom values associated with instances using the given computeValue delegate.

Provides custom values associated with instances using the given .

Delegate to compute the value associated with a given instance. Optional equality comparer to determine equivalent instances that have the same value. If no comparer is provided, then is used by default.

this hold onto analyzer executor context which will be used later to put context information in analyzer exception if it occurs.

Stores the results of analyzer execution: 1. Local and non-local diagnostics, per-analyzer. 2. Analyzer execution times, if requested.

Analyzers corresponding to this analysis result.

Syntax diagnostics reported by the .

Semantic diagnostics reported by the .

Diagnostics in additional files reported by the .

Compilation diagnostics reported by the .

Analyzer telemetry info (register action counts and execution times).

Gets all the diagnostics reported by the given .

Gets all the diagnostics reported by all the .

Stores the results of analyzer execution: 1. Local and non-local diagnostics, per-analyzer. 2. Analyzer execution times, if requested.

Filters down the given to only retain the analyzers which have not completed execution. If the is non-null, then return the analyzers which have not fully exected on the filterScope. Otherwise, return the analyzers which have not fully executed on the entire compilation.

Analyzers to be filtered. Optional scope for filtering. Analyzers which have not fully executed on the given , if non-null, or the entire compilation, if is null.

Scope for analyzer execution. This scope could either be the entire compilation for all analyzers (command line build) or could be scoped to a specific tree/span and/or a subset of analyzers (CompilationWithAnalyzers).

Original filter file for the input analysis scope. Normally, this is the same as , except for SymbolStart/End action execution where original input file/span for diagnostic request can require analyzing other files/spans which have partial definitions for the symbol being analyzed. This property is used to ensure that SymbolStart action and SymbolEnd action both receive this same original filter file.

Original filter span for the input analysis scope. Normally, this is the same as , except for SymbolStart/End action execution where original input file/span for diagnostic request can require analyzing other files/spans which have partial definitions for the symbol being analyzed. This property is used to ensure that SymbolStart action and SymbolEnd action both receive this same original filter span.

Syntax trees on which we need to perform syntax analysis.

Non-source files on which we need to perform analysis.

True if we need to perform only syntax analysis for a single source or additional file.

True if we need to perform analysis for a single source or additional file.

Flag indicating if this analysis scope contains all analyzers from the corresponding , i.e. is the same set as . This flag is used to improve the performance for check for batch compilation scenario, where this flag is always true.

True if we are performing syntactic or semantic analysis for a single source file with a single analyzer in scope, which is a .

True if we are performing semantic analysis for a single source file with a single analyzer in scope, which is a .

Contains the counts of registered actions for an analyzer.

Count of registered compilation start actions.

Count of registered compilation end actions.

Count of registered compilation actions.

Count of registered syntax tree actions.

Count of registered additional file actions.

Count of registered semantic model actions.

Count of registered symbol actions.

Count of registered symbol start actions.

Count of registered symbol end actions.

Count of registered syntax node actions.

Count of code block start actions.

Count of code block end actions.

Count of code block actions.

Count of Operation actions.

Count of Operation block start actions.

Count of Operation block end actions.

Count of Operation block actions.

Returns true if there are any actions that need to run on executable code.

Returns true if there are any analyzer action callbacks that are driven by compilation events, such as , , etc. Many callbacks into the diagnostics analyzers are driven in the by compilation events added to the . For these callbacks to be executed, the analyzer driver host needs to force complete the events in the relevant part of the compilation, i.e. relevant tree(s) or entire compilation. This force complete operation incurs a performance cost, which can be avoided if the analyzer(s) to be executed, such as syntax-only analyzers, do not register any actions which are driven by compilation events. Note that is an exception as it is *always* generated as soon as the is created. Any action callbacks driven off do not need any force completion and hence do not need to be accounted by this boolean flag.

This flag is primarily intended for performance improvements in certain analyzer execution code paths.

Gets a value indicating whether the analyzer supports concurrent execution.

Contains telemetry info for a specific analyzer, such as count of registered actions, the total execution time, etc.

Count of registered compilation start actions.

Count of registered compilation end actions.

Count of registered compilation actions.

Count of registered syntax tree actions.

Count of registered additional file actions.

Count of registered semantic model actions.

Count of registered symbol actions.

Count of registered symbol start actions.

Count of registered symbol end actions.

Count of registered syntax node actions.

Count of registered code block start actions.

Count of registered code block end actions.

Count of registered code block actions.

Count of registered operation actions.

Count of registered operation block start actions.

Count of registered operation block end actions.

Count of registered operation block actions.

Count of registered suppression actions. This is the same as count of s as each suppressor has a single suppression action, i.e. .

Total execution time.

Gets a value indicating whether the analyzer supports concurrent execution.

Create telemetry info for a specific analyzer, such as count of registered actions, the total execution time, etc.

Comparer that should be used for all analyzer config keys. This is a case-insensitive comparison based on Unicode case sensitivity rules for identifiers.

Get an analyzer config value for the given key, using the .

Enumerates unique keys of all available options in no specific order.

Not implemented by the derived type.

Provide options from an analyzer config file keyed on a source file.

Gets global options that do not apply to any specific file

Get options for a given .

Get options for a given

Driver to execute diagnostic analyzers for a given compilation. It uses a of s to drive its analysis.

Set of diagnostic suppressions that are suppressed via analyzer suppression actions.

Set of diagnostics that have already been processed for application of programmatic suppressions.

Flag indicating if the include any which can suppress reported analyzer/compiler diagnostics.

Filtered diagnostic severities in the compilation, i.e. diagnostics with effective severity from this set should not be reported. PERF: If all supported diagnostics for an analyzer are from this set, we completely skip executing the analyzer.

Unsuppressed analyzers that need to be executed.

Cache of additional analyzer actions to be executed per symbol per analyzer, which are registered in symbol start actions. We cache the tuple: 1. myActions: analyzer actions registered in the symbol start actions of containing namespace/type, which are to be executed for this symbol 2. childActions: analyzer actions registered in this symbol's start actions, which are to be executed for member symbols.

Default analysis mode for generated code.

This mode should always guarantee that analyzer action callbacks are enabled for generated code, i.e. is set. However, the default diagnostic reporting mode is liable to change in future.

Map from non-concurrent analyzers to the gate guarding callback into the analyzer.

Map from analyzers to their setting.

The set of registered analyzer actions.

Set of unsuppressed analyzers that report non-configurable or custom configurable diagnostics that cannot be suppressed with end user configuration.

Set of analyzers that have registered symbol start analyzer actions.

True if all analyzers need to analyze and report diagnostics in generated code - we can assume all code to be non-generated code.

True if no analyzer needs generated code analysis - we can skip all analysis on a generated code symbol/tree.

Lazily populated dictionary indicating whether a source file is a generated code file or not - we populate it lazily to avoid realizing all syntax trees in the compilation upfront.

Lazily populated dictionary from tree to declared symbols with GeneratedCodeAttribute.

Lazily populated dictionary from tree to analyzers that are suppressed on the entire tree.

Lazily populated set of diagnostic IDs which are suppressed for some part of the compilation (tree/folder/entire compilation), but the analyzer reporting the diagnostic is itself not suppressed for the entire compilation, i.e. the analyzer belongs to .

Lazily populated dictionary from symbol to a bool indicating if it is a generated code symbol.

Lazily populated dictionary indicating whether a source file has any hidden regions - we populate it lazily to avoid realizing all syntax trees in the compilation upfront.

Symbol for .

Driver task which initializes all analyzers. This task is initialized and executed only once at start of analysis.

Flag to indicate if the was successfully started.

Primary driver task which processes all events, runs analyzer actions and signals completion of at the end.

Number of worker tasks processing compilation events and executing analyzer actions.

Events queue for analyzer execution.

that is fed the diagnostics as they are computed.

Create an analyzer driver.

The set of analyzers to include in the analysis AnalyzerManager to manage analyzers for analyzer host's lifetime. Filtered diagnostic severities in the compilation, i.e. diagnostics with effective severity from this set should not be reported. Delegate to identify if the given trivia is a comment.

Initializes the and related actions maps for the analyzer driver. It kicks off the task for initialization. Note: This method must be invoked exactly once on the driver.

Returns true if all analyzers need to analyze and report diagnostics in generated code - we can assume all code to be non-generated code.

Attaches a pre-populated event queue to the driver and processes all events in the queue.

Compilation events to analyze. Scope of analysis. Cancellation token to abort analysis. Driver must be initialized before invoking this method, i.e. method must have been invoked and must be non-null.

Attaches event queue to the driver and start processing all events pertaining to the given analysis scope.

Compilation events to analyze. Scope of analysis. Boolean flag indicating whether we should only process the already populated events or wait for . Cancellation token to abort analysis. Driver must be initialized before invoking this method, i.e. method must have been invoked and must be non-null.

Create an and attach it to the given compilation.

The compilation to which the new driver should be attached. The set of analyzers to include in the analysis. Options that are passed to analyzers. AnalyzerManager to manage analyzers for the lifetime of analyzer host. Delegate to add diagnostics generated for exceptions from third party analyzers. Report additional information related to analyzers, such as analyzer execution time. Filtered diagnostic severities in the compilation, i.e. diagnostics with effective severity from this set should not be reported. Track diagnostic ids which are suppressed through options. The new compilation with the analyzer driver attached. A cancellation token that can be used to abort analysis. A newly created analyzer driver Note that since a compilation is immutable, the act of creating a driver and attaching it produces a new compilation. Any further actions on the compilation should use the new compilation.

Returns all diagnostics computed by the analyzers since the last time this was invoked. If has been completed with all compilation events, then it waits for task for the driver to finish processing all events and generate remaining analyzer diagnostics.

Returns an array of s for all along with to be logged by the .

Return a task that completes when the driver is initialized.

Return a task that completes when the driver is done producing diagnostics.

Tries to execute symbol action, symbol start/end actions and declaration actions for the given symbol.

indicating the current state of processing of the given compilation event.

Returns true if all the diagnostics that can be produced by this analyzer are suppressed through options.

GetSyntax() for the given SyntaxReference.

Topmost declaration node for analysis.

All member declarations within the declaration.

All descendant nodes for syntax node actions.

Flag indicating if this is a partial analysis.

Used to represent state of processing of a .

Subset of processed analyzers. NOTE: This property is only non-null for .

Driver to execute diagnostic analyzers for a given compilation. It uses a of s to drive its analysis.

Create an analyzer driver.

The set of analyzers to include in the analysis A delegate that returns the language-specific kind for a given syntax node AnalyzerManager to manage analyzers for the lifetime of analyzer host. Filtered diagnostic severities in the compilation, i.e. diagnostics with effective severity from this set should not be reported. Delegate to identify if the given trivia is a comment.

Execute syntax node, code block and operation actions for all declarations for the given symbol.

Execute syntax node, code block and operation actions for the given declaration.

grouped by , and possibly other entities, such as , , etc.

Contains the core execution logic for callbacks into analyzers.

Pooled object that carries the info needed to process a reported diagnostic from a syntax node action.

An optional filter span, which if non-null, indicates that diagnostics reported within this span are considered local diagnostics, and those reported outside this span are considered non-local. NOTE: is a pooled type that is always used from a single thread, hence it is safe to expose a public mutable field.

The values in this map convert to using .

Creates to execute analyzer actions with given arguments

Compilation to be used in the analysis. Analyzer options. Optional delegate to add non-categorized analyzer diagnostics. Delegate which is invoked when an analyzer throws an exception. Delegate can do custom tasks such as report the given analyzer exception diagnostic, report a non-fatal watson for the exception, etc. Optional delegate which is invoked when an analyzer throws an exception as an exception filter. Delegate can do custom tasks such as crash hosting process to create a dump. Delegate to determine if the given analyzer is compiler analyzer. We need to special case the compiler analyzer at few places for performance reasons. Analyzer manager to fetch supported diagnostics. Delegate to fetch the gate object to guard all callbacks into the analyzer. It should return a unique gate object for the given analyzer instance for non-concurrent analyzers, and null otherwise. All analyzer callbacks for non-concurrent analyzers will be guarded with a lock on the gate. Delegate to get a semantic model for the given syntax tree which can be shared across analyzers. for analysis. Delegate to identify if analysis should be skipped on generated code. Delegate to identify if diagnostic reported while analyzing generated code should be suppressed. Delegate to identify if the given location is in generated code. Delegate to identify if the given analyzer is suppressed for the given tree. Flag indicating whether we need to log analyzer execution time. Optional delegate to add categorized local analyzer diagnostics. Optional delegate to add categorized non-local analyzer diagnostics. Optional thread-safe delegate to add diagnostic suppressions from suppressors.

Executes the for the given analyzer.

Session scope to store register session wide analyzer actions. Severity filter for analysis. Cancellation token. Note that this API doesn't execute any registered by the Initialize invocation. Use API to get execute these actions to get the per-compilation analyzer actions.

Executes the compilation start actions.

whose compilation start actions are to be executed. Compilation scope to store the analyzer actions. Cancellation token.

Executes the symbol start actions.

Symbol whose symbol start actions are to be executed. whose symbol start actions are to be executed. Symbol scope to store the analyzer actions. Flag indicating if the symbol being analyzed is generated code. Cancellation token.

Executes the given diagnostic suppressor.

Suppressor to be executed. Reported analyzer/compiler diagnostics that can be suppressed. Cancellation token.

Executes compilation actions or compilation end actions.

Compilation actions to be executed. Analyzer whose actions are to be executed. Compilation event. Cancellation token.

Execute the symbol actions on the given symbol.

Execute the symbol end actions on the given namespace or type containing symbol for the process member symbol for the given analyzer.

Symbol whose actions are to be executed. Completed member symbol. Analyzer whose actions are to be executed. Delegate to get topmost declaration node for a symbol declaration reference. Optional filter span for analysis. Flag indicating if the containing symbol being analyzed is generated code.

Tries to execute the symbol end actions on the given symbol for the given analyzer.

Symbol actions to be executed. Analyzer whose actions are to be executed. Symbol event to be analyzed. Delegate to get topmost declaration node for a symbol declaration reference. Optional filter span for analysis. Flag indicating if the symbol being analyzed is generated code. Cancellation token. True, if successfully executed the actions for the given analysis scope OR all the actions have already been executed for the given analysis scope. False, if there are some pending actions.

Execute the semantic model actions on the given semantic model.

Semantic model actions to be executed. Analyzer whose actions are to be executed. Semantic model to analyze. Optional filter span for analysis. Flag indicating if the syntax tree being analyzed is generated code. Cancellation token.

Execute the syntax tree actions on the given syntax tree.

Syntax tree actions to be executed. Analyzer whose actions are to be executed. Syntax tree to analyze. Optional filter span within the for analysis. Flag indicating if the syntax tree being analyzed is generated code. Cancellation token.

Execute the additional file actions.

Actions to be executed. Analyzer whose actions are to be executed. Additional file to analyze. Optional filter span within the for analysis. Cancellation token.

Execute code block actions for the given analyzer for the given declaration.

Execute operation block actions for the given analyzer for the given declaration.

Execute syntax node actions for the given analyzer for the given declaration.

Execute operation actions for the given analyzer for the given declaration.

True, if successfully executed the actions for the given analysis scope OR all the actions have already been executed for the given analysis scope. False, if there are some pending actions that are currently being executed on another thread.

Represents analyzers stored in an analyzer assembly file.

Analyzer are read from the file, owned by the reference, and doesn't change since the reference is accessed until the reference object is garbage collected. If you need to manage the lifetime of the analyzer reference (and the file stream) explicitly use .

Creates an AnalyzerFileReference with the given and .

Full path of the analyzer assembly. Loader for obtaining the from the

Adds the of defined in this assembly reference of given .

Opens the analyzer dll with the metadata reader and builds a map of language -> analyzer type names.

The PE image format is invalid. IO error reading the metadata.

Represents an in-memory analyzer reference image.

If a specific analyzer failed to load the namespace-qualified name of its type, null otherwise.

Error message.

Error code.

Exception that was thrown while loading the analyzer. May be null.

If is , returns the compiler version referenced by the analyzer assembly. Otherwise, returns null.

Manages properties of analyzers (such as registered actions, supported diagnostics) for analyzer host's lifetime and executes the callbacks into the analyzers. It ensures the following for the lifetime of analyzer host: 1) is invoked only once per-analyzer. 2) is invoked only once per-analyzer. 3) registered during Initialize are invoked only once per-compilation per-analyzer and analyzer options.

Cached mapping of localizable strings in this descriptor to any exceptions thrown while obtaining them.

Map from (symbol, analyzer) to count of its member symbols whose symbol declared events are not yet processed.

Symbol declared events for symbols with pending symbol end analysis for given analyzer.

Task to compute HostSessionStartAnalysisScope for session wide analyzer actions, i.e. AnalyzerActions registered by analyzer's Initialize method. These are run only once per every analyzer.

Task to compute HostCompilationStartAnalysisScope for per-compilation analyzer actions, i.e. AnalyzerActions registered by analyzer's CompilationStartActions.

Task to compute HostSymbolStartAnalysisScope for per-symbol analyzer actions, i.e. AnalyzerActions registered by analyzer's SymbolStartActions.

Supported diagnostic descriptors for diagnostic analyzer, if any.

Supported suppression descriptors for diagnostic suppressor, if any.

Compute and exception handler for the given .

Get all the analyzer actions to execute for the given analyzer against a given compilation. The returned actions include the actions registered during method as well as the actions registered during for the given compilation.

Get the per-symbol analyzer actions to be executed by the given analyzer. These are the actions registered during the various RegisterSymbolStartAction method invocations for the given symbol on different analysis contexts.

Returns true if the given analyzer has enabled concurrent execution by invoking .

Returns for the given analyzer. If an analyzer hasn't configured generated code analysis, returns .

Return of given .

Returns true if all the diagnostics that can be produced by this analyzer are suppressed through options.

Options passed to .

A set of additional non-code text files that can be used by analyzers.

A set of options keyed to or .

Creates analyzer options to be passed to .

A set of additional non-code text files that can be used by analyzers. A set of per-tree options that can be used by analyzers.

Creates analyzer options to be passed to .

A set of additional non-code text files that can be used by analyzers.

Returns analyzer options with the given .

Tries to get configured severity for the given for the given from bulk configuration analyzer config options, i.e. 'dotnet_analyzer_diagnostic.category-%RuleCategory%.severity = %severity%' or 'dotnet_analyzer_diagnostic.severity = %severity%'

Represents an analyzer assembly reference that contains diagnostic analyzers.

Represents a logical location of the analyzer reference, not the content of the reference. The content might change in time. A snapshot is taken when the compiler queries the reference for its analyzers.

Full path describing the location of the analyzer reference, or null if the reference has no location.

Path or name used in error messages to identity the reference.

Should not be null.

A unique identifier for this analyzer reference.

Should not be null. Note that this and serve different purposes. An analyzer reference may not have a path, but it always has an ID. Further, two analyzer references with different paths may represent two copies of the same analyzer, in which case the IDs should also be the same.

Gets all the diagnostic analyzers defined in this assembly reference, irrespective of the language supported by the analyzer. Use this method only if you need all the analyzers defined in the assembly, without a language context. In most instances, either the analyzer reference is associated with a project or is being queried for analyzers in a particular language context. If so, use method.

Gets all the diagnostic analyzers defined in this assembly reference for the given .

Language name.

Gets all the source generators defined in this assembly reference.

Gets all the generators defined in this assembly reference for the given .

Language name.

A queue whose enqueue and dequeue operations can be performed in parallel.

The type of values kept by the queue.

The number of unconsumed elements in the queue.

Adds an element to the tail of the queue. This method will throw if the queue is completed.

The queue is already completed. The value to add.

Tries to add an element to the tail of the queue. This method will return false if the queue is completed.

The value to add.

Attempts to dequeue an existing item and return whether or not it was available.

Gets a value indicating whether the queue has completed.

Signals that no further elements will be enqueued. All outstanding and future Dequeue Task will be cancelled.

The queue is already completed.

Same operation as except it will not throw if the queue is already completed.

Whether or not the operation succeeded.

Gets a task that transitions to a completed state when or is called. This transition will not happen synchronously. This Task will not complete until it has completed all existing values returned from .

Gets a task whose result is the element at the head of the queue. If the queue is empty, the returned task waits for an element to be enqueued. If is called before an element becomes available, the returned task is cancelled.

Cancels a if a given is canceled.

The type of value returned by a successfully completed . The to cancel. The .

A state object for tracking cancellation and a TaskCompletionSource.

The type of value returned from a task. We use this class so that we only allocate one object to support all continuations required for cancellation handling, rather than a special closure and delegate for each one.

Initializes a new instance of the class.

The task completion source. The cancellation token.

Gets the cancellation token.

Gets the Task completion source.

Gets or sets the cancellation token registration.

Provider that caches semantic models for requested trees, with a strong reference to the model. Clients using this provider are responsible for maintaining the lifetime of the entries in this cache, and should invoke and to clear entries when appropriate. For example, uses this provider to ensure that semantic model instances are shared between the compiler and analyzers for improved analyzer execution performance. The underlying executing analyzers clears per-tree entries in the cache whenever a has been processed, indicating all relevant analyzers have executed on the corresponding syntax tree for the event. Similarly, it clears the entire compilation wide cache whenever a has been processed, indicating all relevant analyzers have executed on the entire compilation.

Wrapper over the core which holds a strong reference to key-value pairs for the lifetime of a compilation that this provider is associated with. This ensures that values are never re-computed for equivalent keys while analyzing each compilation, improving overall analyzer performance.

The last event placed into a compilation's event queue.

The first event placed into a compilation's event queue.

Optional filter span for a synthesized CompilationUnitCompletedEvent generated for span-based semantic diagnostic computation. Such synthesized events are used primarily for performance improvements when running compiler analyzer in span-based mode in the IDE, such as computing diagnostics for the lightbulb for the current line. Note that such a synthesized CompilationUnitCompletedEvent with non-null FilterSpan is not a true compilation unit completed event, but just a stub event to drive span-based semantic model action callbacks for analyzer execution. This event will eventually be followed by a true CompilationUnitCompletedEvent with null FilterSpan when the entire compilation unit has actually completed. See https://github.com/dotnet/roslyn/issues/56843 for details.

Builder for storing current, possibly partial, analysis results: 1. Diagnostics reported by analyzers. 2. AnalyzerTelemetryInfo.

Set of exception diagnostics reported for exceptions thrown by the analyzers.

Underlying with a non-null , used to drive analyzer execution.

Analyzers to execute on the compilation.

Options to configure analyzer execution.

An optional cancellation token which can be used to cancel analysis. Note: This token is only used if the API invoked to get diagnostics doesn't provide a cancellation token.

Creates a new compilation by attaching diagnostic analyzers to an existing compilation.

The original compilation. The set of analyzers to include in future analyses. Options that are passed to analyzers.

Creates a new compilation by attaching diagnostic analyzers to an existing compilation.

The original compilation. The set of analyzers to include in future analyses. Options to configure analyzer execution.

Returns diagnostics produced by all .

Returns diagnostics produced by given .

Analyzers whose diagnostics are required. All the given analyzers must be from the analyzers passed into the constructor of . Cancellation token.

Executes all and returns the corresponding with all diagnostics and telemetry info.

Executes the given and returns the corresponding with all diagnostics and telemetry info.

Analyzers whose analysis results are required. All the given analyzers must be from the analyzers passed into the constructor of . Cancellation token.

Returns all diagnostics produced by compilation and by all .

Returns diagnostics produced by compilation actions of all .

Returns diagnostics produced by compilation actions of given .

Analyzers whose diagnostics are required. All the given analyzers must be from the analyzers passed into the constructor of . Cancellation token.

Returns syntax diagnostics produced by all from analyzing the given . Depending on analyzers' behavior, returned diagnostics can have locations outside the tree, and some diagnostics that would be reported for the tree by an analysis of the complete compilation can be absent.

Syntax tree to analyze. Cancellation token.

Returns syntax diagnostics produced by all from analyzing the given , optionally scoped to a . Depending on analyzers' behavior, returned diagnostics can have locations outside the tree or filter span, and some diagnostics that would be reported for the tree by an analysis of the complete compilation can be absent.

Syntax tree to analyze. Optional filter span to analyze within the tree. Cancellation token.

Returns syntax diagnostics produced by given from analyzing the given . Depending on analyzers' behavior, returned diagnostics can have locations outside the tree, and some diagnostics that would be reported for the tree by an analysis of the complete compilation can be absent.

Syntax tree to analyze. Analyzers whose diagnostics are required. All the given analyzers must be from the analyzers passed into the constructor of . Cancellation token.

Returns syntax diagnostics produced by given from analyzing the given , optionally scoped to a . Depending on analyzers' behavior, returned diagnostics can have locations outside the tree or filter span, and some diagnostics that would be reported for the tree by an analysis of the complete compilation can be absent.

Syntax tree to analyze. Analyzers whose diagnostics are required. All the given analyzers must be from the analyzers passed into the constructor of . Optional filter span to analyze within the tree. Cancellation token.

Returns an populated with produced by all from analyzing the given . Depending on analyzers' behavior, some diagnostics that would be reported for the tree by an analysis of the complete compilation can be absent.

Syntax tree to analyze. Cancellation token.

Returns an populated with produced by all from analyzing the given , optionally scoped to a . Depending on analyzers' behavior, some diagnostics that would be reported for the tree by an analysis of the complete compilation can be absent.

Syntax tree to analyze. Optional filter span to analyze within the tree. Cancellation token.

Returns an populated with produced by given from analyzing the given . Depending on analyzers' behavior, some diagnostics that would be reported for the tree by an analysis of the complete compilation can be absent.

Syntax tree to analyze. Analyzers whose diagnostics are required. All the given analyzers must be from the analyzers passed into the constructor of . Cancellation token.

Returns an populated with produced by given from analyzing the given , optionally scoped to a . Depending on analyzers' behavior, some diagnostics that would be reported for the tree by an analysis of the complete compilation can be absent.

Returns an populated with produced by all from analyzing the given additional . The given must be part of for the for this CompilationWithAnalyzers instance. Depending on analyzers' behavior, some diagnostics that would be reported for the file by an analysis of the complete compilation can be absent.

Additional file to analyze. Cancellation token.

Returns an populated with produced by given from analyzing the given additional . The given must be part of for the for this CompilationWithAnalyzers instance. Depending on analyzers' behavior, some diagnostics that would be reported for the file by an analysis of the complete compilation can be absent.

Additional file to analyze. Analyzers whose diagnostics are required. All the given analyzers must be from the analyzers passed into the constructor of . Cancellation token.

Returns an populated with produced by all from analyzing the given additional , optionally scoped to a . The given must be part of for the for this CompilationWithAnalyzers instance. Depending on analyzers' behavior, some diagnostics that would be reported for the file by an analysis of the complete compilation can be absent.

Additional file to analyze. Optional filter span to analyze within the . Cancellation token.

Returns an populated with produced by given from analyzing the given additional , optionally scoped to a . The given must be part of for the for this CompilationWithAnalyzers instance. Depending on analyzers' behavior, some diagnostics that would be reported for the file by an analysis of the complete compilation can be absent.

Additional file to analyze. Optional filter span to analyze within the . Analyzers whose diagnostics are required. All the given analyzers must be from the analyzers passed into the constructor of . Cancellation token.

Returns semantic diagnostics produced by all from analyzing the given , optionally scoped to a . Depending on analyzers' behavior, some diagnostics that would be reported for the tree by an analysis of the complete compilation can be absent.

Semantic model representing the syntax tree to analyze. An optional span within the tree to scope analysis. Cancellation token.

Returns semantic diagnostics produced by the given from analyzing the given , optionally scoped to a . Depending on analyzers' behavior, some diagnostics that would be reported for the tree by an analysis of the complete compilation can be absent.

Semantic model representing the syntax tree to analyze. An optional span within the tree to scope analysis. Analyzers whose diagnostics are required. All the given analyzers must be from the analyzers passed into the constructor of . Cancellation token.

Semantic model representing the syntax tree to analyze. An optional span within the tree to scope analysis. Cancellation token.

Returns an populated with produced by the given from analyzing the given , optionally scoped to a . Depending on analyzers' behavior, some diagnostics that would be reported for the tree by an analysis of the complete compilation can be absent.

Core method to compute analyzer diagnostics for the given . This method is used to compute diagnostics for the entire compilation or a specific file. It executes the required analyzers and stores the reported analyzer diagnostics into .

PERF: We re-use the underlying for the below cases: 1. If the given analysis scope only includes the . 2. If we are only computing syntax diagnostics. For rest of the cases, we always fork the underlying with a new compilation event queue, execute the analyzers on this forked compilation and then discard this compilation. Using a forked compilation allows us to avoid performing expensive partial analysis state tracking for analyzer execution. It is the responsibility of the CompilationWithAnalyzers host to club the analyzer diagnostics requests into minimal number of calls into CompilationWithAnalyzers to get the optimum performance by minimize compilation forking. See https://github.com/dotnet/roslyn/issues/66714 for more details.

Given a set of compiler or generated , returns the effective diagnostics after applying the below filters: 1) specified for the given . 2) specified for the given . 3) Diagnostic suppression through applied . 4) Pragma directives for the given .

Returns true if all the diagnostics that can be produced by this analyzer are suppressed through options.

Analyzer to be checked for suppression. Compilation options. Optional delegate which is invoked when an analyzer throws an exception. Delegate can do custom tasks such as report the given analyzer exception diagnostic, report a non-fatal watson for the exception, etc.

This method should be invoked when the analyzer host is disposing off the given . It clears the cached internal state (supported descriptors, registered actions, exception handlers, etc.) for analyzers.

Analyzers whose state needs to be cleared.

Gets telemetry info for the given analyzer, such as count of registered actions, the total execution time (if is true), etc.

Gets the count of registered actions for the analyzer.

Gets the execution time for the given analyzer.

Options to configure analyzer execution within .

Options passed to s.

An optional delegate to be invoked when an analyzer throws an exception.

An optional delegate to be invoked when an analyzer throws an exception as an exception filter.

Flag indicating whether analysis can be performed concurrently on multiple threads.

Flag indicating whether analyzer execution time should be logged.

Flag indicating whether analyzer diagnostics with should be reported.

Creates a new .

Options that are passed to analyzers. Action to invoke if an analyzer throws an exception. Flag indicating whether analysis can be performed concurrently on multiple threads. Flag indicating whether analyzer execution time should be logged.

Creates a new .

Options that are passed to analyzers. Action to invoke if an analyzer throws an exception. Action to invoke if an analyzer throws an exception as an exception filter. Flag indicating whether analysis can be performed concurrently on multiple threads. Flag indicating whether analyzer execution time should be logged. Flag indicating whether analyzer diagnostics with should be reported.

DiagnosticAnalyzer for compiler's syntax/semantic/compilation diagnostics.

Per-compilation DiagnosticAnalyzer for compiler's syntax/semantic/compilation diagnostics.

Context for initializing an analyzer. Analyzer initialization can use an to register actions to be executed at any of: compilation start, compilation end, completion of parsing a code document, completion of semantic analysis of a code document, completion of semantic analysis of a symbol, start of semantic analysis of a method body or an expression appearing outside a method body, completion of semantic analysis of a method body or an expression appearing outside a method body, or completion of semantic analysis of a syntax node.

Register an action to be executed at compilation start. A compilation start action can register other actions and/or collect state information to be used in diagnostic analysis, but cannot itself report any s.

Action to be executed at compilation start.

Action to be executed at compilation end.

Register an action to be executed at completion of semantic analysis of a document, which will operate on the of the document. A semantic model action reports s about the model.

Action to be executed for a document's .

Register an action to be executed at completion of semantic analysis of an with an appropriate Kind. A symbol action reports s about s.

Action to be executed for an . Action will be executed only if an 's Kind matches one of the values.

Register an action to be executed at completion of semantic analysis of an with an appropriate Kind. A symbol action reports s about s.

Action to be executed for an . Action will be executed only if an 's Kind matches one of the values.

Action to be executed. Action will be executed only if an 's Kind matches the given .

Register an action to be executed at the start of semantic analysis of a method body or an expression appearing outside a method body. A code block start action can register other actions and/or collect state information to be used in diagnostic analysis, but cannot itself report any s.

Enum type giving the syntax node kinds of the source language for which the action applies. Action to be executed at the start of semantic analysis of a code block.

Register an action to be executed after semantic analysis of a method body or an expression appearing outside a method body. A code block action reports s about code blocks.

Action to be executed for a code block.

Register an action to be executed at completion of parsing of a code document. A syntax tree action reports s about the of a document.

Action to be executed at completion of parsing of a document.

Register an action to be executed for each non-code document. An additional file action reports s about the of a document.

Action to be executed for each non-code document.

Register an action to be executed at completion of semantic analysis of a with an appropriate Kind. A syntax node action can report s about s, and can also collect state information to be used by other syntax node actions or code block end actions.

Enum type giving the syntax node kinds of the source language for which the action applies. Action to be executed at completion of semantic analysis of a . Action will be executed only if a 's Kind matches one of the syntax kind values.

Register an action to be executed at the start of semantic analysis of a method body or an expression appearing outside a method body. An operation block start action can register other actions and/or collect state information to be used in diagnostic analysis, but cannot itself report any s.

Action to be executed at the start of semantic analysis of an operation block.

Register an action to be executed after semantic analysis of a method body or an expression appearing outside a method body. An operation block action reports s about operation blocks.

Action to be executed for an operation block.

Register an action to be executed at completion of semantic analysis of an with an appropriate Kind. An operation action can report s about s, and can also collect state information to be used by other operation actions or code block end actions.

Action to be executed at completion of semantic analysis of an . Action will be executed only if an 's Kind matches one of the operation kind values.

Enable concurrent execution of analyzer actions registered by this analyzer. An analyzer that registers for concurrent execution can have better performance than a non-concurrent analyzer. However, such an analyzer must ensure that its actions can execute correctly in parallel.

Even when an analyzer registers for concurrent execution, certain related actions are *never* executed concurrently. For example, end actions registered on any analysis unit (compilation, code block, operation block, etc.) are by definition semantically dependent on analysis from non-end actions registered on the same analysis unit. Hence, end actions are never executed concurrently with non-end actions operating on the same analysis unit.

Configure analysis mode of generated code for this analyzer. Non-configured analyzers will default to an appropriate default mode for generated code. It is recommended for the analyzer to invoke this API with the required setting.

Indicates the minimum reported diagnostic severity for this analysis context. Analyzer diagnostics with severity lesser than this severity are not reported.

Attempts to compute or get the cached value provided by the given for the given . Note that the pair {, } acts as the key. Reusing the same instance across analyzer actions and/or analyzer instances can improve the overall analyzer performance by avoiding recomputation of the values.

The type of the value associated with the key. for which the value is queried. Provider that computes the underlying value. Value associated with the key. Returns true on success, false otherwise.

Flags to configure mode of generated code analysis.

Disable analyzer action callbacks and diagnostic reporting for generated code. Analyzer driver will not make callbacks into the analyzer for entities (source files, symbols, etc.) that it classifies as generated code. Additionally, any diagnostic reported by the analyzer with location in generated code will not be reported.

Enable analyzer action callbacks for generated code. Analyzer driver will make callbacks into the analyzer for all entities (source files, symbols, etc.) in the compilation, including generated code.

Enable reporting diagnostics on generated code. Analyzer driver will not suppress any analyzer diagnostic based on whether or not it's location is in generated code.

Context for a compilation start action. A compilation start action can use a to register actions to be executed at any of: compilation end, completion of parsing a code document, completion of semantic analysis of a code document, completion of semantic analysis of a symbol, start of semantic analysis of a method body or an expression appearing outside a method body, completion of semantic analysis of a method body or an expression appearing outside a method body, or completion of semantic analysis of a syntax node.

that is the subject of the analysis.

Options specified for the analysis.

Token to check for requested cancellation of the analysis.

Action to be executed at compilation end.

Register an action to be executed at completion of semantic analysis of a document, which will operate on the of the document. A semantic model action reports s about the model.

Action to be executed for a document's .

Register an action to be executed at completion of semantic analysis of an with an appropriate Kind. A symbol action reports s about s.

Action to be executed for an . Action will be executed only if an 's Kind matches one of the values.

Register an action to be executed at completion of semantic analysis of an with an appropriate Kind. A symbol action reports s about s.

Action to be executed for an . Action will be executed only if an 's Kind matches one of the values.

Action to be executed. Action will be executed only if an 's Kind matches the given .

Enum type giving the syntax node kinds of the source language for which the action applies. Action to be executed at the start of semantic analysis of a code block.

Register an action to be executed at the end of semantic analysis of a method body or an expression appearing outside a method body. A code block action reports s about code blocks.

Action to be executed for a code block.

Action to be executed at the start of semantic analysis of an operation block.

Register an action to be executed after semantic analysis of a method body or an expression appearing outside a method body. An operation block action reports s about operation blocks.

Action to be executed for an operation block.

Register an action to be executed at completion of parsing of a code document. A syntax tree action reports s about the of a document.

Action to be executed at completion of parsing of a document.

Register an action to be executed for each non-code document. An additional file action reports s about the of a document.

Action to be executed for each non-code document.

Action to be executed at completion of semantic analysis of an . Action will be executed only if an 's Kind matches one of the operation kind values.

The type of the value associated with the key. for which the value is queried. Provider that computes the underlying value. Value associated with the key. Returns true on success, false otherwise.

The type of the value associated with the key. instance for which the value is queried. Provider that computes the underlying value. Value associated with the key. Returns true on success, false otherwise.

Context for a compilation action or compilation end action. A compilation action or compilation end action can use a to report s about a .

that is the subject of the analysis.

Options specified for the analysis.

Token to check for requested cancellation of the analysis.

Report a about a .

to be reported.

The type of the value associated with the key. for which the value is queried. Provider that computes the underlying value. Value associated with the key. Returns true on success, false otherwise.

Context for a semantic model action. A semantic model action operates on the of a code document, and can use a to report s about the model.

that is the subject of the analysis.

Options specified for the analysis.

Token to check for requested cancellation of the analysis.

Syntax tree for the being analyzed.

Optional filter span within the for which to compute diagnostics. if we are analyzing the entire or the entire compilation.

Indicates if the underlying is generated code.

Report a about a .

to be reported.

Context for a symbol action. A symbol action can use a to report s about an .

that is the subject of the analysis.

containing the .

Options specified for the analysis.

Optional filter tree being analyzed. if we are analyzing the entire compilation.

Optional filter span within the for which to compute diagnostics. if we are analyzing the entire or the entire compilation.

This property is guaranteed to be if is .

Token to check for requested cancellation of the analysis.

Indicates if the is generated code.

Report a about an .

to be reported.

Context for a symbol start action to analyze a symbol and its members. A symbol start/end action can use a to report s about code within a and its members.

that is the subject of the analysis.

containing the .

Options specified for the analysis.

Indicates if the is generated code.

Optional filter tree being analyzed. if we are analyzing the entire compilation.

Optional filter span within the for which to compute diagnostics. if we are analyzing the entire or the entire compilation.

This property is guaranteed to be if is .

Token to check for requested cancellation of the analysis.

Register an action to be executed at end of semantic analysis of an and its members. A symbol end action reports s about the code within a and its members.

Action to be executed at compilation end.

Enum type giving the syntax node kinds of the source language for which the action applies. Action to be executed at the start of semantic analysis of a code block.

Register an action to be executed after semantic analysis of a method body or an expression appearing outside a method body. A code block action reports s about code blocks.

Action to be executed for a code block.

Action to be executed at the start of semantic analysis of an operation block.

Register an action to be executed after semantic analysis of a method body or an expression appearing outside a method body. An operation block action reports s about operation blocks.

Action to be executed for an operation block.

Action to be executed at completion of semantic analysis of an . Action will be executed only if an 's Kind matches one of the operation kind values.

Context for a code block start action. A code block start action can use a to register actions to be executed at any of: completion of semantic analysis of a method body or an expression appearing outside a method body, or completion of semantic analysis of a syntax node.

Method body or expression subject to analysis.

for which the code block provides a definition or value.

that can provide semantic information about the s in the code block.

Options specified for the analysis.

Syntax tree corresponding to the code block being analyzed.

Optional filter span within the for which to compute diagnostics. if we are analyzing the entire or the entire compilation.

Indicates if the is generated code.

Token to check for requested cancellation of the analysis.

Register an action to be executed at the end of semantic analysis of a method body or an expression appearing outside a method body. A code block end action reports s about code blocks.

Action to be executed at the end of semantic analysis of a code block.

Action to be executed at completion of semantic analysis of a . Action will be executed only if a 's Kind matches one of the syntax kind values.

Context for a code block action or code block end action. A code block action or code block end action can use a to report s about a code block.

Code block that is the subject of the analysis.

for which the code block provides a definition or value.

that can provide semantic information about the s in the code block.

Options specified for the analysis.

Syntax tree for the code block being analyzed.

Optional filter span within the for which to compute diagnostics. if we are analyzing the entire or the entire compilation.

Indicates if the is generated code.

Token to check for requested cancellation of the analysis.

Report a about a code block.

to be reported.

Context for an operation block start action. An operation block start action can use an to register actions to be executed at any of: completion of semantic analysis of a method body or an expression appearing outside a method body, or completion of semantic analysis of an operation.

One or more operation blocks that are the subject of the analysis. This includes all blocks associated with the , such as method body, field/property/constructor/parameter initializer(s), attributes, etc.

Note that the operation blocks are not in any specific order.

for which the provides a definition or value.

containing the .

Options specified for the analysis.

Syntax tree for the being analyzed.

Optional filter span within the for which to compute diagnostics. if we are analyzing the entire or the entire compilation.

Indicates if the is generated code.

Token to check for requested cancellation of the analysis.

Register an action to be executed at the end of semantic analysis of a method body or an expression appearing outside a method body. A code block end action reports s about code blocks.

Action to be executed at the end of semantic analysis of a code block.

Register an action to be executed at completion of semantic analysis of an operation with an appropriate Kind. An operation action can report s about s, and can also collect state information to be used by other operation actions or operation block end actions.

Action to be executed at completion of semantic analysis of an . Action will be executed only if an 's Kind matches one of the operation kind values.

Gets a for a given from this analysis context's .

Operation block.

Context for an operation block action or operation block end action. An operation block action or operation block end action can use an to report s about an operation block.

Note that the operation blocks are not in any specific order.

for which the provides a definition or value.

containing the .

Options specified for the analysis.

Syntax tree for the being analyzed.

Optional filter span within the for which to compute diagnostics. if we are analyzing the entire or the entire compilation.

Indicates if the is generated code.

Token to check for requested cancellation of the analysis.

Report a about a code block.

to be reported.

Gets a for a given from this analysis context's .

Operation block.

Context for a syntax tree action. A syntax tree action can use a to report s about a for a code document.

that is the subject of the analysis.

Options specified for the analysis.

Optional filter span within the for which to compute diagnostics. if we are analyzing the entire or the entire compilation.

Indicates if the is generated code.

Token to check for requested cancellation of the analysis.

Report a about a .

to be reported.

Context for an additional file action. An additional file action can use an to report s about a non-source document.

that is the subject of the analysis.

Options specified for the analysis.

Optional filter span within the for which to compute diagnostics. if we are analyzing the entire or the entire compilation.

Token to check for requested cancellation of the analysis.

Compilation being analyzed.

Report a diagnostic for the given . A diagnostic in a non-source document should be created with a non-source , which can be created using API.

Context for a syntax node action. A syntax node action can use a to report s for a .

that is the subject of the analysis.

for the declaration containing the syntax node.

that can provide semantic information about the .

containing the .

Options specified for the analysis.

Syntax tree for the being analyzed.

Optional filter span within the for which to compute diagnostics. if we are analyzing the entire or the entire compilation.

Indicates if the is generated code.

Token to check for requested cancellation of the analysis.

Report a about a .

to be reported.

Context for an operation action. An operation action can use an to report s for an .

that is the subject of the analysis.

for the declaration containing the operation.

containing the .

Options specified for the analysis.

Syntax tree for the being analyzed.

Optional filter span within the for which to compute diagnostics. if we are analyzing the entire or the entire compilation.

Indicates if the is generated code.

Token to check for requested cancellation of the analysis.

Report a about a .

to be reported.

Gets a for the operation block containing the .

Context for suppressing analyzer and/or compiler non-error diagnostics reported for the compilation.

Analyzer and/or compiler non-error diagnostics reported for the compilation. Each only receives diagnostics whose IDs were declared suppressible in its . This may be a subset of the full set of reported diagnostics, as an optimization for supporting incremental and partial analysis scenarios. A diagnostic is considered suppressible by a DiagnosticSuppressor if *all* of the following conditions are met: 1. Diagnostic is not already suppressed in source via pragma/suppress message attribute. 2. Diagnostic's is not . 3. Diagnostic is not tagged with custom tag.

for the context.

Options specified for the analysis.

Token to check for requested cancellation of the analysis.

Report a for a reported diagnostic.

Gets a for the given , which is shared across all analyzers.

The base type for diagnostic analyzers.

Returns a set of descriptors for the diagnostics that this analyzer is capable of producing.

Called once at session start to register actions in the analysis context.

Place this attribute onto a type to cause it to be considered a diagnostic analyzer.

The source languages to which this analyzer applies. See .

Attribute constructor used to specify automatic application of a diagnostic analyzer.

One language to which the analyzer applies. Additional languages to which the analyzer applies. See .

Returns a new compilation with attached diagnostic analyzers.

Compilation to which analyzers are to be added. The set of analyzers to include in future analyses. Options that are passed to analyzers.

Returns a new compilation with attached diagnostic analyzers.

Compilation to which analyzers are to be added. The set of analyzers to include in future analyses. Options to configure analyzer execution within .

Queue to store analyzer diagnostics on the .

Simple diagnostics queue: maintains all diagnostics reported by all analyzers in a single queue.

Categorized diagnostics queue: maintains separate set of simple diagnostic queues for local semantic, local syntax and non-local diagnostics for every analyzer.

Scope for setting up analyzers for an entire session, automatically associating actions with analyzers.

Scope for setting up analyzers for a compilation, automatically associating actions with analyzers.

Scope for setting up analyzers for code within a symbol and its members.

Scope for setting up analyzers for a code block, automatically associating actions with analyzers.

Scope for setting up analyzers for an operation block, automatically associating actions with analyzers.

Scope for setting up analyzers for an entire session, capable of retrieving the actions.

Scope for setting up analyzers for a compilation, capable of retrieving the actions.

Scope for setting up analyzers for analyzing a symbol and its members.

Scope for setting up analyzers for a code block, capable of retrieving the actions.

Actions registered by a particular analyzer.

Append analyzer actions from to actions from this instance.

Analyzer actions to append.

The base type for diagnostic suppressors that can programmatically suppress analyzer and/or compiler non-error diagnostics.

Returns a set of descriptors for the suppressions that this suppressor is capable of producing.

Suppress analyzer and/or compiler non-error diagnostics reported for the compilation. This may be a subset of the full set of reported diagnostics, as an optimization for supporting incremental and partial analysis scenarios. A diagnostic is considered suppressible by a DiagnosticSuppressor if *all* of the following conditions are met: 1. Diagnostic is not already suppressed in source via pragma/suppress message attribute. 2. Diagnostic's is not . 3. Diagnostic is not tagged with custom tag.

Represents a source file or an additional file. For source files, is non-null and is null. For additional files, is non-null and is null.

Provides custom values associated with instances using the given computeValue delegate.

Provides custom values associated with instances using the given .

Programmatic suppression of a by a .

Creates a suppression of a with the given .

Descriptor for the suppression, which must be from for the creating this suppression. to be suppressed, which must be from for the suppression context in which this suppression is being created.

Descriptor for this suppression.

Diagnostic suppressed by this suppression.

Attempts to resolve the "Target" argument of the global SuppressMessageAttribute to symbols in compilation.

Indicates if resolved "Target" argument is in Roslyn's format. Resolved symbols for the the "Target" argument of the global SuppressMessageAttribute.

An event for each declaration in the program (namespace, type, method, field, parameter, etc). Note that some symbols may have multiple declarations (namespaces, partial types) and may therefore have multiple events.

Provides custom values associated with instances using the given computeValue delegate.

Provides values associated with instances using the given .

Represents an analyzer reference that can't be resolved.

For error reporting only, can't be used to reference an analyzer assembly.

Contains information about the source of a programmatic diagnostic suppression produced by an .

Represents a set of filtered diagnostic severities. Currently, we only support filtering out Hidden and Info severities during build.

Contains information about the source of diagnostic suppression.

of the suppressed diagnostic.

If the diagnostic was suppressed by an attribute, then returns that attribute. Otherwise, returns null.

If the diagnostic was suppressed by one or more programmatic suppressions by (s), then returns the corresponding s, in no specific order. Otherwise, returns an empty array.

Is this an that the loader considers to be part of the hosting process. Either part of the compiler itself or the process hosting the compiler.

For a given return the location it was originally added from. This will return null for any value that was not directly added through the loader.

The base implementation for . This type provides caching and tracking of inputs given to .

This type generally assumes that files on disk aren't changing, since it ensure that two calls to will always return the same thing, per that interface's contract.

Loads analyzer assemblies from their original locations in the file system. Assemblies will only be loaded from the locations specified when the loader is instantiated.

This type is meant to be used in scenarios where it is OK for the analyzer assemblies to be locked on disk for the lifetime of the host; for example, csc.exe and vbc.exe. In scenarios where support for updating or deleting the analyzer on disk is required a different loader should be used.

Set of analyzer dependencies original full paths to the data calculated for that path

Access must be guarded by

Mapping of analyzer dependency original full path and culture to the real satellite assembly path. If the satellite assembly doesn't exist for the original analyzer and culture, the real path value stored will be null.

Access must be guarded by

Maps analyzer dependency simple names to the set of original full paths it was loaded from. This _only_ tracks the paths provided to the analyzer as it's a place to look for indirect loads.

Access must be guarded by

A collection of s that can be used to override the assembly resolution process.

When multiple resolvers are present they are consulted in-order, with the first resolver to return a non-null winning.

Whether or not we're disposed. Once disposed, all functionality on this type should throw.

The implementation needs to load an with the specified . The parameter is the original path. It may be different than as that is empty on .NET Core.

This method should return an instance or throw.

Determines if the satisfies the request for . This is partial'd out as each runtime has a different definition of matching name.

Get the and the path it should be loaded from for the given original analyzer path

This is used in the implementation of the loader instead of because we only want information for registered paths. Using unregistered paths inside the implementation should result in errors.

Get the path a satellite assembly should be loaded from for the given original analyzer path and culture

This is used during assembly resolve for satellite assemblies to determine the path from where the satellite assembly should be loaded for the specified culture. This method calls to ensure this path contains the satellite assembly.

Return the best (original, real) path information for loading an assembly with the specified .

When overridden in a derived class, allows substituting an assembly path after we've identified the context to load an assembly in, but before the assembly is actually loaded from disk. This is used to substitute out the original path with the shadow-copied version.

When overridden in a derived class, allows substituting a satellite assembly path after we've identified the context to load a satellite assembly in, but before the satellite assembly is actually loaded from disk. This is used to substitute out the original path with the shadow-copied version.

When is overridden this returns the most recent real path calculated for the

Iterates the if any, to see if any of them can resolve the given to an .

The name of the assembly to resolve An if one of the resolvers is successful, or

The default implementation is to simply load in place.

Return an which does not lock assemblies on disk that is most appropriate for the current platform.

A shadow copy path will be created on Windows and this value will be the base directory where shadow copy assemblies are stored.

Handles loading analyzer assemblies and their dependencies. Before an analyzer assembly is loaded with , its location and the location of all of its dependencies must first be specified by calls to .

To the extent possible, implementations should remain consistent in the face of exceptions and allow the caller to handle them. This allows the caller to decide how to surface issues to the user and whether or not they are fatal. For example, if asked to load an a non-existent or inaccessible file a command line tool may wish to exit immediately, while an IDE may wish to keep going and give the user a chance to correct the issue.

Given the full path to an assembly on disk, loads and returns the corresponding object.

Multiple calls with the same path should return the same instance. is null. is not a full path.

Adds a file to consider when loading an analyzer or its dependencies.

is null. is not a full path.

Allows a host to override how assembly resolution is performed by the .

Attempts to resolve an assembly by name.

The assembly to resolve The resolved assembly, or

The base directory for shadow copies. Each instance of gets its own subdirectory under this directory. This is also the starting point for scavenge operations.

The directory where this instance of will shadow-copy assemblies, and the mutex created to mark that the owner of it is still active.

Abstracts the ability to classify and load messages for error codes. Allows the error infrastructure to be reused between C# and VB.

Caches the return values for .

Given an error code, get the severity (warning or error) of the code.

Load the message for the given error code. If the message contains "fill-in" placeholders, those should be expressed in standard string.Format notation and be in the string.

Get an optional localizable title for the given diagnostic code.

Get an optional localizable description for the given diagnostic code.

Get a localizable message format string for the given diagnostic code.

Get an optional help link for the given diagnostic code.

Get the diagnostic category for the given diagnostic code. Default category is .

Get the text prefix (e.g., "CS" for C#) used on error messages.

Get the warning level for warnings (e.g., 1 or greater for C#). VB does not have warning levels and always uses 1. Errors should return 0.

Type that defines error codes. For testing purposes only.

Create a simple language specific diagnostic for given error code.

Create a simple language specific diagnostic with no location for given info.

Create a simple language specific diagnostic for given error code.

Given a message identifier (e.g., CS0219), severity, warning as error and a culture, get the entire prefix (e.g., "error CS0219: Warning as Error:" for C# or "error BC42024:" for VB) used on error messages.

Convert given symbol to string representation.

Given an error code (like 1234) return the identifier (CS1234 or BC1234).

Produces the filtering action for the diagnostic based on the options passed in.

A new with new effective severity based on the options or null if the diagnostic has been suppressed.

Filter a based on the compilation options so that /nowarn and /warnaserror etc. take effect.options

A with effective severity based on option or null if suppressed.

Takes an exception produced while writing to a file stream and produces a diagnostic.

Represents a diagnostic, such as a compiler error or a warning, along with the location where it occurred.

A diagnostic (such as a compiler error or a warning), along with the location where it occurred.

The default warning level, which is also used for non-error diagnostics.

The warning level used for hidden and info diagnostics. Because these diagnostics interact with other editor features, we want them to always be produced unless /warn:0 is set.

The maximum warning level represented by a large value of 9999.

Creates a instance.

A describing the diagnostic An optional primary location of the diagnostic. If null, will return . Arguments to the message of the diagnostic The instance.

Creates a instance.

A describing the diagnostic. An optional primary location of the diagnostic. If null, will return . An optional set of name-value pairs by means of which the analyzer that creates the diagnostic can convey more detailed information to the fixer. If null, will return . Arguments to the message of the diagnostic. The instance.

Creates a instance.

A describing the diagnostic. An optional primary location of the diagnostic. If null, will return . An optional set of additional locations related to the diagnostic. Typically, these are locations of other items referenced in the message. If null, will return an empty list. An optional set of name-value pairs by means of which the analyzer that creates the diagnostic can convey more detailed information to the fixer. If null, will return . Arguments to the message of the diagnostic. The instance.

Creates a instance.

A describing the diagnostic. An optional primary location of the diagnostic. If null, will return . Effective severity of the diagnostic. An optional set of additional locations related to the diagnostic. Typically, these are locations of other items referenced in the message. If null, will return an empty list. An optional set of name-value pairs by means of which the analyzer that creates the diagnostic can convey more detailed information to the fixer. If null, will return . Arguments to the message of the diagnostic. The instance.

Creates a instance which is localizable.

An identifier for the diagnostic. For diagnostics generated by the compiler, this will be a numeric code with a prefix such as "CS1001". The category of the diagnostic. For diagnostics generated by the compiler, the category will be "Compiler". The diagnostic message text. The diagnostic's effective severity. The diagnostic's default severity. True if the diagnostic is enabled by default The warning level, greater than 0 if severity is ; otherwise 0. An optional short localizable title describing the diagnostic. An optional longer localizable description for the diagnostic. An optional hyperlink that provides more detailed information regarding the diagnostic. An optional primary location of the diagnostic. If null, will return . An optional set of additional locations related to the diagnostic. Typically, these are locations of other items referenced in the message. If null, will return an empty list. An optional set of custom tags for the diagnostic. See for some well known tags. If null, will return an empty list. An optional set of name-value pairs by means of which the analyzer that creates the diagnostic can convey more detailed information to the fixer. If null, will return . The instance.

Creates a instance which is localizable.

An identifier for the diagnostic. For diagnostics generated by the compiler, this will be a numeric code with a prefix such as "CS1001". The category of the diagnostic. For diagnostics generated by the compiler, the category will be "Compiler". The diagnostic message text. The diagnostic's effective severity. The diagnostic's default severity. True if the diagnostic is enabled by default The warning level, greater than 0 if severity is ; otherwise 0. Flag indicating whether the diagnostic is suppressed by a source suppression. An optional short localizable title describing the diagnostic. An optional longer localizable description for the diagnostic. An optional hyperlink that provides more detailed information regarding the diagnostic. An optional primary location of the diagnostic. If null, will return . An optional set of additional locations related to the diagnostic. Typically, these are locations of other items referenced in the message. If null, will return an empty list. An optional set of custom tags for the diagnostic. See for some well known tags. If null, will return an empty list. An optional set of name-value pairs by means of which the analyzer that creates the diagnostic can convey more detailed information to the fixer. If null, will return . The instance.

Gets the diagnostic descriptor, which provides a description about a .

Gets the diagnostic identifier. For diagnostics generated by the compiler, this will be a numeric code with a prefix such as "CS1001".

Gets the category of diagnostic. For diagnostics generated by the compiler, the category will be "Compiler".

Get the culture specific text of the message.

Gets the default of the diagnostic's .

To get the effective severity of the diagnostic, use .

Gets the effective of the diagnostic.

To get the default severity of diagnostic's , use . To determine if this is a warning treated as an error, use .

Gets the warning level. This is 0 for diagnostics with severity , otherwise an integer greater than zero.

Returns true if the diagnostic has a source suppression, i.e. an attribute or a pragma suppression.

Gets the for suppressed diagnostics, i.e. = true. Otherwise, returns null.

Returns true if this diagnostic is enabled by default by the author of the diagnostic.

Returns true if this is a warning treated as an error; otherwise false.

True implies = and = .

Gets the primary location of the diagnostic, or if no primary location.

Gets an array of additional locations related to the diagnostic. Typically these are the locations of other items referenced in the message.

Gets custom tags for the diagnostic.

Gets property bag for the diagnostic. it will return if there is no entry. This can be used to put diagnostic specific information you want to pass around. for example, to corresponding fixer.

Create a new instance of this diagnostic with the Location property changed.

Create a new instance of this diagnostic with the Severity property changed.

Create a new instance of this diagnostic with the suppression info changed.

Create a new instance of this diagnostic with the given programmatic suppression info.

Returns true if the diagnostic location (or any additional location) is within the given tree and intersects with the filterSpanWithinTree, if non-null.

Gets the default warning level for a diagnostic severity. Warning levels are used with the /warn:N command line option to suppress diagnostics over a severity of interest. When N is 0, only error severity messages are produced by the compiler. Values greater than 0 indicated that warnings up to and including level N should also be included.

and are treated as warning level 1. In other words, these diagnostics which typically interact with editor features are enabled unless the special /warn:0 option is set. A value. The default compiler warning level for .

Returns true if a diagnostic is not configurable, i.e. cannot be suppressed or filtered or have its severity changed. For example, compiler errors are always non-configurable.

Returns true if this is an error diagnostic which cannot be suppressed and is guaranteed to break the build. Only diagnostics which have default severity error and are tagged as NotConfigurable fall in this bucket. This includes all compiler error diagnostics and specific analyzer error diagnostics that are marked as not configurable by the analyzer author.

Returns true if this is a unsuppressed diagnostic with an effective error severity.

This type is attached to diagnostics for required language version and should only be used on such diagnostics, as they are recognized by .

Represents a mutable bag of diagnostics. You can add diagnostics to the bag, and also get all the diagnostics out of the bag (the bag implements IEnumerable<Diagnostics>. Once added, diagnostics cannot be removed, and no ordering is guaranteed. It is ok to Add diagnostics to the same bag concurrently on multiple threads. It is NOT ok to Add concurrently with Clear or Free operations.

The bag is optimized to be efficient when containing zero errors.

Return true if the bag is completely empty - not even containing void diagnostics.

This exists for short-circuiting purposes. Use to get a resolved Tuple(Of NamedTypeSymbol, ImmutableArray(Of Diagnostic)) (i.e. empty after eliminating void diagnostics).

Returns true if the bag has any diagnostics with DefaultSeverity=Error. Does not consider warnings or informationals or warnings promoted to error via /warnaserror.

Resolves any lazy diagnostics in the bag. Generally, this should only be called by the creator (modulo pooling) of the bag (i.e. don't use bags to communicate - if you need more info, pass more info).

Returns true if the bag has any non-lazy diagnostics with DefaultSeverity=Error. Does not consider warnings or informationals or warnings promoted to error via /warnaserror.

Does not resolve any lazy diagnostics in the bag. Generally, this should only be called by the creator (modulo pooling) of the bag (i.e. don't use bags to communicate - if you need more info, pass more info).

Add a diagnostic to the bag.

Add multiple diagnostics to the bag.

Add another DiagnosticBag to the bag.

Add another DiagnosticBag to the bag and free the argument.

Seal the bag so no further errors can be added, while clearing it and returning the old set of errors. Return the bag to the pool.

Generally, this should only be called by the creator (modulo pooling) of the bag (i.e. don't use bags to communicate - if you need more info, pass more info). Using an iterator to avoid copying the list. If perf is a problem, create an explicit enumerator type.

Get the underlying concurrent storage, creating it on demand if needed. NOTE: Concurrent Adding to the bag is supported, but concurrent Clearing is not. If one thread adds to the bug while another clears it, the scenario is broken and we cannot do anything about it here.

NOTE: Concurrent Adding to the bag is supported, but concurrent Clearing is not. If one thread adds to the bug while another clears it, the scenario is broken and we cannot do anything about it here.

Provides a description about a

An unique identifier for the diagnostic.

Choose an appropriate diagnostic ID such that it is unique.

A short localizable title describing the diagnostic.

An optional longer localizable description for the diagnostic.

An optional hyperlink that provides more detailed information regarding the diagnostic.

A localizable format message string, which can be passed as the first argument to when creating the diagnostic message with this descriptor.

The category of the diagnostic (like Design, Naming etc.)

The default severity of the diagnostic.

Returns true if the diagnostic is enabled by default.

Custom tags for the diagnostic.

Create a DiagnosticDescriptor, which provides description about a . NOTE: For localizable , and/or , use constructor overload .

A unique identifier for the diagnostic. For example, code analysis diagnostic ID "CA1001". A short title describing the diagnostic. For example, for CA1001: "Types that own disposable fields should be disposable". A format message string, which can be passed as the first argument to when creating the diagnostic message with this descriptor. For example, for CA1001: "Implement IDisposable on '{0}' because it creates members of the following IDisposable types: '{1}'." The category of the diagnostic (like Design, Naming etc.). For example, for CA1001: "Microsoft.Design". Default severity of the diagnostic. True if the diagnostic is enabled by default. An optional longer description of the diagnostic. An optional hyperlink that provides a more detailed description regarding the diagnostic. Optional custom tags for the diagnostic. See for some well known tags. Choose an appropriate diagnostic ID such that it is unique.

Create a DiagnosticDescriptor, which provides description about a .

A unique identifier for the diagnostic. For example, code analysis diagnostic ID "CA1001". A short localizable title describing the diagnostic. For example, for CA1001: "Types that own disposable fields should be disposable". A localizable format message string, which can be passed as the first argument to when creating the diagnostic message with this descriptor. For example, for CA1001: "Implement IDisposable on '{0}' because it creates members of the following IDisposable types: '{1}'." The category of the diagnostic (like Design, Naming etc.). For example, for CA1001: "Microsoft.Design". Default severity of the diagnostic. True if the diagnostic is enabled by default. An optional longer localizable description of the diagnostic. An optional hyperlink that provides a more detailed description regarding the diagnostic. Optional custom tags for the diagnostic. See for some well known tags. Example descriptor for rule CA1001:


                internal static DiagnosticDescriptor Rule = new DiagnosticDescriptor(RuleId,
                    new LocalizableResourceString(nameof(FxCopRulesResources.TypesThatOwnDisposableFieldsShouldBeDisposable), FxCopRulesResources.ResourceManager, typeof(FxCopRulesResources)),
                    new LocalizableResourceString(nameof(FxCopRulesResources.TypeOwnsDisposableFieldButIsNotDisposable), FxCopRulesResources.ResourceManager, typeof(FxCopRulesResources)),
                    FxCopDiagnosticCategory.Design,
                    DiagnosticSeverity.Warning,
                    isEnabledByDefault: true,
                    helpLinkUri: "http://msdn.microsoft.com/library/ms182172.aspx",
                    customTags: DiagnosticCustomTags.Microsoft);

Choose an appropriate diagnostic ID such that it is unique.

Gets the effective severity of diagnostics created based on this descriptor and the given .

Compilation options

Returns true if diagnostic descriptor is not configurable, i.e. cannot be suppressed or filtered or have its severity changed. For example, compiler errors are always non-configurable.

Returns true if diagnostic descriptor is custom configurable, i.e. analyzer supports custom ways for configuring diagnostic severity that may not be understood by the compiler.

Returns true if diagnostic descriptor is a built-in compiler diagnostic or is not configurable or is custom configurable.

Formats messages.

Formats the message using the optional .

The diagnostic. The formatter; or null to use the default formatter. The formatted message.

A DiagnosticInfo object has information about a diagnostic, but without any attached location information.

More specialized diagnostics with additional information (e.g., ambiguity errors) can derive from this class to provide access to additional information about the error, such as what symbols were involved in the ambiguity.

The error code, as an integer.

Returns the effective severity of the diagnostic: whether this diagnostic is informational, warning, or error. If IsWarningsAsError is true, then this returns , while returns .

Returns whether this diagnostic is informational, warning, or error by default, based on the error code. To get diagnostic's effective severity, use .

Gets the warning level. This is 0 for diagnostics with severity , otherwise an integer greater than zero.

Returns true if this is a warning treated as an error.

True implies = and = .

Get the diagnostic category for the given diagnostic code. Default category is .

If a derived class has additional information about other referenced symbols, it can expose the locations of those symbols in a general way, so they can be reported along with the error.

Get the message id (for example "CS1001") for the message. This includes both the error number and a prefix identifying the source.

Get the text of the message in the given language.

For a DiagnosticInfo that is lazily evaluated, this method evaluates it and returns a non-lazy DiagnosticInfo.

Describes how severe a diagnostic is.

Something that is an issue, as determined by some authority, but is not surfaced through normal means. There may be different mechanisms that act on these issues.

Information that does not indicate a problem (i.e. not prescriptive).

Something suspicious but allowed.

Something not allowed by the rules of the language or other authority.

Values for severity that are used internally by the compiler but are not exposed.

An unknown severity diagnostic is something whose severity has not yet been determined.

If an unknown diagnostic is resolved and found to be unnecessary then it is treated as a "Void" diagnostic

Values for ErrorCode/ERRID that are used internally by the compiler but are not exposed.

The code has yet to be determined.

The code was lazily determined and does not need to be reported.

A diagnostic (such as a compiler error or a warning), along with the location where it occurred.

Get the information about the diagnostic: the code, severity, message, etc.

True if the DiagnosticInfo for this diagnostic requires (or required - this property is immutable) resolution.

Usage is unexpected unless is true.

A program location in source code.

Represents a span of text in a source code file in terms of file name, line number, and offset within line. However, the file is actually whatever was passed in when asked to parse; there may not really be a file.

Path, or null if the span represents an invalid value.

Path may be if not available.

Gets the span.

True if the is a mapped path.

A mapped path is a path specified in source via #line (C#) or #ExternalSource (VB) directives.

Initializes the instance.

The file identifier - typically a relative or absolute path. The start line position. The end line position. is null.

Initializes the instance.

The file identifier - typically a relative or absolute path. The span. is null.

Gets the of the start of the span.

Gets the of the end of the span.

Returns true if the span represents a valid location.

Determines if two FileLinePositionSpan objects are equal.

The path is treated as an opaque string, i.e. a case-sensitive comparison is used.

Determines if two FileLinePositionSpan objects are equal.

Serves as a hash function for FileLinePositionSpan.

The hash code. The path is treated as an opaque string, i.e. a case-sensitive hash is calculated.

Returns a that represents .

The string representation of . Path: (0,0)-(5,6)

A localizable resource string that may possibly be formatted differently depending on culture.

Creates a localizable resource string with no formatting arguments.

nameof the resource that needs to be localized. for the calling assembly. Type handling assembly's resource management. Typically, this is the static class generated for the resources file from which resources are accessed.

Creates a localizable resource string that may possibly be formatted differently depending on culture.

A string that may possibly be formatted differently depending on culture. NOTE: Types implementing must be serializable.

FixedLocalizableString representing an empty string.

Fired when an exception is raised by any of the public methods of . If the exception handler itself throws an exception, that exception is ignored.

Formats the value of the current instance using the optionally specified format.

Formats the value of the current instance using the optionally specified format. Provides the implementation of ToString. ToString will provide a default value if this method throws an exception.

Provides the implementation of GetHashCode. GetHashCode will provide a default value if this method throws an exception.

Provides the implementation of Equals. Equals will provide a default value if this method throws an exception.

Flag indicating if any methods on this type can throw exceptions from public entrypoints.

A program location in source code.

Location kind (None/SourceFile/MetadataFile).

Returns true if the location represents a specific location in a source code file.

Returns true if the location is in metadata.

The syntax tree this location is located in or null if not in a syntax tree.

Returns the metadata module the location is associated with or null if the module is not available.

Might return null even if returns true. The module symbol might not be available anymore, for example, if the location is serialized and deserialized.

The location within the syntax tree that this location is associated with.

If returns False this method returns an empty which starts at position 0.

Gets the location in terms of path, line and column.

that contains path, line and column information. Returns an invalid span (see ) if the information is not available. The values are not affected by line mapping directives (#line in C# or #ExternalSource in VB).

Gets the location in terms of path, line and column after applying source line mapping directives (#line in C# or #ExternalSource in VB).

that contains file, line and column information, or an invalid span (see ) if not available.

A location of kind LocationKind.None.

Creates an instance of a for a span in a .

Creates an instance of a for a span in a file.

Creates an instance of a for a span in a file with a mapped file and span.

Specifies the kind of location (source vs. metadata).

Unspecified location.

The location represents a position in a source file.

The location represents a metadata file.

The location represents a position in an XML file.

The location in some external file.

A program location in metadata.

A class that represents no location at all. Useful for errors in command line options, for example.

Describes how to report a warning diagnostic.

Report a diagnostic by default.

Report a diagnostic as an error.

Report a diagnostic as a warning even though /warnaserror is specified.

Report a diagnostic as an info.

Report a diagnostic as hidden.

Suppress a diagnostic.

A program location in source code.

Provides a description about a programmatic suppression of a by a .

An unique identifier for the suppression.

Identifier of the suppressed diagnostic, i.e. .

A localizable justification about the suppression.

Create a SuppressionDescriptor, which provides a justification about a programmatic suppression of a . NOTE: For localizable , use constructor overload .

A unique identifier for the suppression. For example, suppression ID "SP1001". Identifier of the suppressed diagnostic, i.e. . For example, compiler warning Id "CS0649". Justification for the suppression. For example: "Suppress CS0649 on fields marked with YYY attribute as they are implicitly assigned.".

Create a SuppressionDescriptor, which provides a localizable justification about a programmatic suppression of a .

Returns a flag indicating if the suppression is disabled for the given .

Compilation options

Indicates that the diagnostic is related to some unnecessary source code.

Indicates that the diagnostic is related to edit and continue.

Indicates that the diagnostic is related to build.

Indicates that the diagnostic is reported by the compiler.

Indicates that the diagnostic can be used for telemetry

Indicates that the diagnostic is not configurable, i.e. it cannot be suppressed or filtered or have its severity changed.

Indicates that the analyzer reporting the diagnostic supports custom severity configuration mechanism(s) to allow end users to configure effective severity of the diagnostic. Such analyzers are always considered to be enabled by the compiler and always receive analyzer callbacks. Additionally, severity of the diagnostics reported with this custom tag is not altered by analyzer config options to configure severity, i.e. 'dotnet_diagnostic' and 'dotnet_analyzer_diagnostic' entries.

See https://github.com/dotnet/roslyn/issues/52991 for further details.

Indicates that the diagnostic is related to an exception thrown by a .

Indicates that the diagnostic is an obsolete diagnostic with a custom ID specified by the 'DiagnosticId' property on 'ObsoleteAttribute'.

Indicates that the diagnostic is a compilation end diagnostic reported from a compilation end action.

A program location in an XML file.

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

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

If is . The documentation comment Id for this symbol, if it can be created. if it cannot be.

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

If is .

Gets all declaration symbols that match the declaration id string

Try to get all the declaration symbols that match the declaration id string. Returns true if at least one symbol matches.

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

Gets the symbols that match the reference id string.

Try to get all symbols that match the reference id string. Returns true if at least one symbol matches.

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

Callers should only call into and should check to see if it failed (in the case of an arbitrary symbol) or that it produced an expected value (in the case a known symbol type was used).

This will always succeed for a or . It may not succeed for other symbols. Once used, an instance of this visitor should be discarded. Specifically it is stateful, and will stay in the failed state once it transitions there.

If we hit anything we don't know about, indicate failure.

WARN: This is a test hook - do not take a dependency on this.

A class used to provide XML documentation to the compiler for members from metadata. A custom implementation of this class should be returned from a DocumentationResolver to provide XML documentation comments from custom caches or locations.

Fetches a documentation comment for the given member ID.

The documentation member ID of the item to fetch. The preferred culture to receive a comment in. Null if there is no preference. This is a preference only, and providers may choose to provide results from another culture if the preferred culture was unavailable. A cancellation token for the search. A DocumentationComment.

DocumentationProviders are compared when determining whether an AssemblySymbol can be reused. Hence, if multiple instances can represent the same documentation, it is imperative that Equals (and GetHashCode) be overridden to capture this fact. Otherwise, it is possible to end up with multiple AssemblySymbols for the same assembly, which plays havoc with the type hierarchy.

DocumentationProviders are compared when determining whether an AssemblySymbol can be reused. Hence, if multiple instances can represent the same documentation, it is imperative that GetHashCode (and Equals) be overridden to capture this fact. Otherwise, it is possible to end up with multiple AssemblySymbols for the same assembly, which plays havoc with the type hierarchy.

A trivial DocumentationProvider which never returns documentation.

Used by the DocumentationCommentCompiler(s) to check doc comments for XML parse errors. As a performance optimization, this class tries to re-use the same underlying instance when possible.

Current text to validate.

We use to validate XML doc comments. Unfortunately it cannot be reset and thus can't be pooled. Each time we need to validate a fragment of XML we "append" it to the underlying text reader, implemented by this class, and advance the reader. By the end of the fragment validation, we keep the reader open in a state that is ready for the next fragment validation unless the fragment was invalid, in which case we need to create a new XmlReader. That is why pretends that the stream has extra spaces at the end. That should be sufficient for to not reach the end of this reader before the next fragment is appended, unless the current fragment is malformed in one way or another.

Specifies the different documentation comment processing modes.

Order matters: least processing to most processing.

Treats documentation comments as regular comments.

Parses documentation comments as structured trivia, but do not report any diagnostics.

Parses documentation comments as structured trivia and report diagnostics.

Represents text to be embedded in a PDB.

The maximum number of bytes in to write out uncompressed. This prevents wasting resources on compressing tiny files with little to negative gain in PDB file size. Chosen as the point at which we start to see > 10% blob size reduction using all current source files in corefx and roslyn as sample data.

The path to the file to embed.

See remarks of Empty file paths are disallowed, as the debugger finds source by looking up files by their name (and then verifying their signature)

Hash algorithm to use to calculate checksum of the text that's saved to PDB.

The hash of the uncompressed bytes that's saved to the PDB.

The content that will be written to the PDB.

Internal since this is an implementation detail. The only public contract is that you can pass EmbeddedText instances to Emit. It just so happened that doing this up-front was most practical and efficient, but we don't want to be tied to it. For efficiency, the format of this blob is exactly as it is written to the PDB,which prevents extra copies being made during emit. The first 4 bytes (little endian int32) indicate the format: 0: data that follows is uncompressed Positive: data that follows is deflate compressed and value is original, uncompressed size Negative: invalid at this time, but reserved to mark a different format in the future.

Constructs a for embedding the given .

The file path (pre-normalization) to use in the PDB. The source text to embed. is null. is null. empty. cannot be embedded (see ).

Constructs an from stream content.

The file path (pre-normalization) to use in the PDB. The stream. Hash algorithm to use to calculate checksum of the text that's saved to PDB. is null. is null. is empty. doesn't support reading or seeking. is not supported. An I/O error occurs. Reads from the beginning of the stream. Leaves the stream open.

Constructs an from bytes.

The file path (pre-normalization) to use in the PDB. The bytes. Hash algorithm to use to calculate checksum of the text that's saved to PDB. is default-initialized. is null. is empty. is not supported. An I/O error occurs. Reads from the beginning of the stream. Leaves the stream open. is null. is empty.

Creates the blob to be saved to the PDB.

Encoding to use when there is no byte order mark (BOM) on the stream. This encoder may throw a if the stream contains invalid UTF-8 bytes.

Encoding to use when UTF-8 fails. We try to find the following, in order, if available: 1. The default ANSI codepage 2. CodePage 1252. 3. Latin1.

Initializes an instance of from the provided stream. This version differs from in two ways: 1. It attempts to minimize allocations by trying to read the stream into a byte array. 2. If is null, it will first try UTF-8 and, if that fails, it will try CodePage 1252. If CodePage 1252 is not available on the system, then it will try Latin1.

The stream containing encoded text. 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 heuristics are used to determine the encoding. If these heuristics fail the decoding is assumed to be Encoding.Default. Note that if the stream starts with Byte Order Mark the value of is ignored. Indicates if the file can be embedded in the PDB. Hash algorithm used to calculate document checksum. 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 occurred while reading from the stream.

Try to create a from the given stream using the given encoding.

The input stream containing the encoded text. The stream will not be closed. The expected encoding of the stream. The actual encoding used may be different if byte order marks are detected. The checksum algorithm to use. Throw if binary (non-text) data is detected. Indicates if the text can be embedded in the PDB. The decoded from the stream. The decoder was unable to decode the stream with the given encoding. Error reading from stream.

Some streams are easily represented as bytes.

The stream The bytes, if available. True if the stream's bytes could easily be read, false otherwise.

Read the contents of a FileStream into a byte array.

The FileStream with encoded text. A byte array filled with the contents of the file. True if a byte array could be created.

A composite of a sequence of s.

Validates the arguments passed to against the published contract.

True if should bother to proceed with copying.

Reduces the number of segments toward the target number of segments, if the number of segments is deemed to be too large (beyond the maximum).

Determines the segment size to use for call to CombineSegments, that will result in the segment count being reduced to less than or equal to the target segment count.

Determines the segment count that would result if the segments of size less than or equal to the specified segment size were to be combined.

Combines contiguous segments with lengths that are each less than or equal to the specified segment size.

Compute total text length and total size of storage buffers held

Trim excessive inaccessible text.

Delegates to SourceTexts within the CompositeText to determine line information.

The starting line number for the correspondingly indexed SourceTexts in _compositeText.Segments. Multiple consecutive entries could indicate the same line number if the corresponding segments don't contain newline characters.

This will be of the same length as _compositeText.Segments

Determines the line number of a position in this CompositeText

A optimized for very large sources. The text is stored as a list of chunks (char arrays).

internal for unit testing

Called from to initialize the . Thereafter, the collection is cached.

A new representing the individual text lines.

Append chunk to writer (may reuse char array)

Immutable representation of a line number and position within a SourceText instance.

A that represents position 0 at line 0.

Initializes a new instance of a with the given line and character.

The line of the line position. The first line in a file is defined as line 0 (zero based line numbering). The character position in the line. or is less than zero.

The line number. The first line in a file is defined as line 0 (zero based line numbering).

The character position within the line.

Determines whether two are the same.

Determines whether two are different.

Determines whether two are the same.

The object to compare.

Determines whether two are the same.

The object to compare.

Provides a hash function for .

Provides a string representation for .

0,10

Immutable span represented by a pair of line number and index within the line.

Creates .

Start position. End position. precedes .

Gets the start position of the span.

Gets the end position of the span.

Provides a string representation for .

(0,0)-(5,6)

Specifies a hash algorithms used for hashing source files.

No algorithm specified.

Secure Hash Algorithm 1.

Secure Hash Algorithm 2 with a hash size of 256 bits.

Hash algorithms supported by the debugger used for source file checksums stored in the PDB.

Defines a source hash algorithm constant we can re-use when creating source texts for open documents. This ensures that both LSP and documents opened as a text buffer are created with the same checksum algorithm so that we can compare their contents using checksums later on.

An abstraction of source text.

Backing store of

Constructs a from text in a string.

Text. Encoding of the file that the was read from or is going to be saved to. null if the encoding is unspecified. If the encoding is not specified the resulting isn't debuggable. If an encoding-less is written to a file a shall be used as a default. Hash algorithm to use to calculate checksum of the text that's saved to PDB. is null. is not supported.

Constructs a from text in a string.

TextReader length of content from Encoding of the file that the was read from or is going to be saved to. null if the encoding is unspecified. If the encoding is not specified the resulting isn't debuggable. If an encoding-less is written to a file a shall be used as a default. Hash algorithm to use to calculate checksum of the text that's saved to PDB. is null. is not supported.

Constructs a from stream content.

Stream. The stream must be seekable. Data encoding to use if the stream doesn't start with Byte Order Mark specifying the encoding. if not specified. Hash algorithm to use to calculate checksum of the text that's saved to PDB. If the decoded text contains at least two consecutive NUL characters, then an is thrown. True if the text can be passed to and be embedded in a PDB. is null. doesn't support reading or seeking. is not supported. If the given encoding is set to use a throwing decoder as a fallback Two consecutive NUL characters were detected in the decoded text and was true. An I/O error occurs. Reads from the beginning of the stream. Leaves the stream open.

Constructs a from a byte array.

The encoded source buffer. The number of bytes to read from the buffer. Data encoding to use if the encoded buffer doesn't start with Byte Order Mark. if not specified. Hash algorithm to use to calculate checksum of the text that's saved to PDB. If the decoded text contains at least two consecutive NUL characters, then an is thrown. The decoded text. True if the text can be passed to and be embedded in a PDB. The is null. The is negative or longer than the . is not supported. If the given encoding is set to use a throwing decoder as a fallback Two consecutive NUL characters were detected in the decoded text and was true.

Decode text from a stream.

The stream containing encoded text. The encoding to use if an encoding cannot be determined from the byte order mark. The actual encoding used. The decoded text. If the given encoding is set to use a throwing decoder as a fallback

Decode text from a byte array.

The byte array containing encoded text. The count of valid bytes in . The encoding to use if an encoding cannot be determined from the byte order mark. The actual encoding used. The decoded text. If the given encoding is set to use a throwing decoder as a fallback

Check for occurrence of two consecutive NUL (U+0000) characters. This is unlikely to appear in genuine text, so it's a good heuristic to detect binary files.

internal for unit testing

Hash algorithm to use to calculate checksum of the text that's saved to PDB.

Encoding of the file that the text was read from or is going to be saved to. null if the encoding is unspecified.

If the encoding is not specified the source isn't debuggable. If an encoding-less is written to a file a shall be used as a default.

The length of the text in characters.

The size of the storage representation of the text (in characters). This can differ from length when storage buffers are reused to represent fragments/subtext.

Indicates whether this source text can be embedded in the PDB.

If this text was constructed via or , then the canBeEmbedded arg must have been true. Otherwise, must be non-null.

If the text was created from a stream or byte[] and canBeEmbedded argument was true, this provides the embedded text blob that was precomputed using the original stream or byte[]. The precomputation was required in that case so that the bytes written to the PDB match the original bytes exactly (and match the checksum of the original bytes).

Returns a character at given position.

The position to get the character from. The character. When position is negative or greater than .

Copy a range of characters from this SourceText to a destination array.

The container of this .

Gets a that contains the characters in the specified span of this text.

Returns a that has the contents of this text including and after the start position.

Write this to a text writer.

Write a span of text to a text writer.

Cryptographic checksum determined by . Computed using the original bytes that were used to produce this (if any of the From methods were used that take a byte[] or ). Otherwise, computed by writing this back to a (using the provided ), and computing the hash off of that.

Two different instances with the same content (see ) may have different results for this method. This is because different originating bytes may end up with the same final content. For example, a utf8 stream with a byte-order-mark will produce the same contents as a utf8 stream without one. However, these preamble bytes will be part of the checksum, leading to different results. Similarly, two different instances with different contents can have the same checksum in normal scenarios. This is because the use of the can lead to different characters being mapped to the same sequence of encoded bytes. As such, this function should only be used by clients who need to know the exact SHA hash from the original content bytes, and for no other purposes.

Produces a hash of this based solely on the contents it contains. Two different instances that are will have the same content hash. Two instances of with different content are virtually certain to not have the same hash. This hash can be used for fingerprinting of text instances, but does not provide cryptographic guarantees.

This hash is safe to use across platforms and across processes, as long as the same version of Roslyn is used in all those locations. As such, it is safe to use as a fast proxy for comparing text instances in different memory spaces. Different versions of Roslyn may produce different content hashes.

Provides a string representation of the SourceText.

Gets a string containing the characters in specified span.

When given span is outside of the text range.

Constructs a new SourceText from this text with the specified changes.

Changes do not have to be in sorted order. However, will perform better if they are. If any changes are not in bounds of this . If any changes overlap other changes.

Returns a new SourceText with the specified span of characters replaced by the new text.

Returns a new SourceText with the specified range of characters replaced by the new text.

Gets the set of that describe how the text changed between this text an older version. This may be multiple detailed changes or a single change encompassing the entire text.

Gets the set of that describe how the text changed between this text and an older version. This may be multiple detailed changes or a single change encompassing the entire text.

The collection of individual text lines.

Called from to initialize the . Thereafter, the collection is cached.

A new representing the individual text lines.

Compares the content with content of another .

Implements equality comparison of the content of two different instances of .

Detect an encoding by looking for byte order marks.

A buffer containing the encoded text. The length of valid data in the buffer. The length of any detected byte order marks. The detected encoding or null if no recognized byte order mark was present.

Get maximum char count needed to decode the entire stream.

Stream is so big that max char count can't fit in .

An object that contains an instance of a SourceText and raises events when its current instance changes.

The current text instance.

Raised when the current text instance changes.

A read-only, non-seekable over a .

Implementation of based on a input

Underlying string on which this SourceText instance is based

Underlying string which is the source of this SourceText instance

The length of the text represented by .

Returns a character at given position.

The position to get the character from. The character. When position is negative or greater than .

Provides a string representation of the StringBuilderText located within given span.

When given span is outside of the text range.

Implementation of SourceText based on a input

Underlying string which is the source of this instance

The length of the text represented by .

Returns a character at given position.

The position to get the character from. The character. When position is negative or greater than .

Provides a string representation of the StringText located within given span.

When given span is outside of the text range.

A that represents a subrange of another .

Delegates to the SubText's to determine line information.

Determines the line number of a position in this SubText

Describes a single change when a particular span is replaced with a new text.

The original span of the changed text.

The new text.

Initializes a new instance of

The original span of the changed text. The new text.

Provides a string representation for .

Converts a to a .

An empty set of changes.

Represents state for a TextChanged event.

Initializes an instance of .

The text before the change. The text after the change. A set of ranges for the change.

Initializes an instance of .

The text before the change. The text after the change. A set of ranges for the change.

Gets the text before the change.

Gets the text after the change.

Gets the set of ranges for the change.

Represents the change to a span of text.

The span of text before the edit which is being changed

Width of the span after the edit. A 0 here would represent a delete

Initializes a new instance of .

Compares current instance of to another.

Provides hash code for current instance of .

Determines if two instances of are same.

Determines if two instances of are different.

An empty set of changes.

Collapse a set of s into a single encompassing range. If the set of ranges provided is empty, an empty range is returned.

Information about the character boundaries of a single line of text.

Creates a instance.

The source text. The span of the line. An instance of . The span does not represent a text line.

Gets the source text.

Gets the zero-based line number.

Gets the start position of the line.

Gets the end position of the line not including the line break.

Gets the end position of the line including the line break.

Gets the line span not including the line break.

Gets the line span including the line break.

Abstract base class for collections.

The count of items in the collection

Gets the item at the specified index.

The index of the TextLine that encompasses the character position.

Gets a that encompasses the character position.

Gets a corresponding to a character position.

Convert a to a .

Convert a to a position.

Convert a to .

Immutable abstract representation of a span of text. For example, in an error diagnostic that reports a location, it could come from a parsed string, text from a tool editor buffer, etc.

Creates a TextSpan instance beginning with the position Start and having the Length specified with .

Start point of the span.

End of the span.

Length of the span.

Determines whether or not the span is empty.

Determines whether the position lies within the span.

The position to check. true if the position is greater than or equal to Start and strictly less than End, otherwise false.

Determines whether falls completely within this span.

The span to check. true if the specified span falls completely within this span, otherwise false.

Determines whether overlaps this span. Two spans are considered to overlap if they have positions in common and neither is empty. Empty spans do not overlap with any other span.

The span to check. true if the spans overlap, otherwise false.

Returns the overlap with the given span, or null if there is no overlap.

The span to check. The overlap of the spans, or null if the overlap is empty.

Determines whether intersects this span. Two spans are considered to intersect if they have positions in common or the end of one span coincides with the start of the other span.

The span to check. true if the spans intersect, otherwise false.

Determines whether intersects this span. A position is considered to intersect if it is between the start and end positions (inclusive) of this span.

The position to check. true if the position intersects, otherwise false.

Returns the intersection with the given span, or null if there is no intersection.

The span to check. The intersection of the spans, or null if the intersection is empty.

Creates a new from and positions as opposed to a position and length. The returned TextSpan contains the range with inclusive, and exclusive.

Determines if two instances of are the same.

Determines if two instances of are different.

Determines if current instance of is equal to another.

Produces a hash code for .

Provides a string representation for . This representation uses "half-open interval" notation, indicating the endpoint character is not included. Example: [10..20), indicating the text starts at position 10 and ends at position 20 not included.

Compares current instance of with another.

Holder for common Text Utility functions and values

Return startLineBreak = index-1, lengthLineBreak = 2 if there is a \r\n at index-1 Return startLineBreak = index, lengthLineBreak = 1 if there is a 1-char newline at index Return startLineBreak = index+1, lengthLineBreak = 0 if there is no newline at index.

Determine if the character in question is any line break character

Generate a ConstantValue of the same integer type as the argument and offset by the given non-negative amount. Return ConstantValue.Bad if the generated constant would be outside the valid range of the type.

A structure meant to represent a union of and values

Emit the IL for the compilation into the specified stream.

Compilation. Path of the file to which the compilation will be written. Path of the file to which the compilation's debug info will be written. Also embedded in the output file. Null to forego PDB generation. Path of the file to which the compilation's XML documentation will be written. Null to forego XML generation. Path of the file from which the compilation's Win32 resources will be read (in RES format). Null to indicate that there are none. List of the compilation's managed resources. Null to indicate that there are none. To cancel the emit process. Compilation or path is null. Path is empty or invalid. An error occurred while reading or writing a file.

Initializes a new instance of the class.

An ordered set of fully qualified paths which are searched when resolving assembly names. Directory used when resolving relative paths.

Represents that an intermediate result is being captured. This node is produced only as part of a .

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

An id used to match references to the same intermediate result.

Value to be captured.

Represents a point of use of an intermediate result captured earlier. The fact of capturing the result is represented by . This node is produced only as part of a .

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

An id used to match references to the same intermediate result.

True if this reference to the capture initializes the capture. Used when the capture is being initialized by being passed as an parameter.

Represents result of checking whether the is null. For reference types this checks if the is a null reference, for nullable types this checks if the doesn’t have a value. The node is produced as part of a flow graph during rewrite of and nodes.

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Value to check.

Represents a exception instance passed by an execution environment to an exception filter or handler. This node is produced only as part of a .

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Represents the check during initialization of a VB static local that is initialized on the first call of the function, and never again. If the semaphore operation returns true, the static local has not yet been initialized, and the initializer will be run. If it returns false, then the local has already been initialized, and the static local initializer region will be skipped. This node is produced only as part of a .

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

The static local variable that is possibly initialized.

Represents an anonymous function operation in context of a . Current usage: C# lambda expression VB anonymous delegate expression A for the body of the anonymous function is available from the enclosing .

This node is associated with the following operation kinds: This interface is reserved for implementation by its associated APIs. We reserve the right to change it in the future.

Symbol of the anonymous function.

Represents a basic block in a with a sequence of . Once a basic block is entered, all operations in it are always executed. Optional , if non-null, is evaluated after the . Control flow leaves the basic block by taking either the branch or the branch.

Basic block kind (entry, block, or exit).

Sequence of operations in the basic block.

Optional branch value, which if non-null, is evaluated after . For conditional branches, this value is used to represent the condition which determines if is taken or not. For non-conditional branches, this value is used to represent the return or throw value associated with the .

Indicates the condition kind for the branch out of the basic block.

Optional fall through branch executed at the end of the basic block. This branch is null for exit block, and non-null for all other basic blocks.

Optional conditional branch out of the basic block. If non-null, this branch may be taken at the end of the basic block based on the and .

List of basic blocks which have a control flow branch ( or ) into this basic block.

Unique ordinal for each basic block in a , which can be used to index into array.

Indicates if control flow can reach this basic block from the entry block of the graph.

Enclosing region.

kind.

Indicates an entry block for a , which is always the first block in .

Indicates an exit block for a , which is always the last block in .

Indicates an intermediate block for a .

Capture Id is an opaque identifier to represent an intermediate result from an .

Compares s.

Represents a control flow branch from a basic block to a basic block in a .

Source basic block of this branch.

Destination basic block of this branch.

Semantics associated with this branch (such as "regular", "return", "throw", etc).

Indicates if this branch represents of the basic block.

Regions exited if this branch is taken. Ordered from the innermost region to the outermost region.

Regions entered if this branch is taken. Ordered from the outermost region to the innermost region.

The finally regions the control goes through if this branch is taken. Ordered in the sequence by which the finally regions are executed.

Semantics associated with a .

Represents a with no associated semantics.

Represents a regular from a source basic block to a non-null destination basic block.

Represents a to the exit block, i.e. the destination block has .

Represents a with special structured exception handling semantics: 1. The source basic block is the last block of an enclosing finally or filter region. 2. The destination basic block is null.

Represents a to indicate flow transfer to the end of program execution. The destination basic block is null for this branch.

Represents a generated for an with an explicit thrown exception. The destination basic block is null for this branch.

Represents a generated for an with in implicit rethrown exception. The destination basic block is null for this branch.

Represents a generated for error cases.

Represents kind of conditional branch from a .

Indicates no conditional branch from a . Associated is null.

Indicates a conditional branch from a , with a non-null and . If evaluates to false, then the branch is taken.

Indicates a conditional branch from a , with a non-null and . If evaluates to true, then the branch is taken.

Control flow graph representation for a given executable code block . This graph contains a set of s, with an entry block, zero or more intermediate basic blocks and an exit block. Each basic block contains zero or more and explicit (s) to other basic block(s).

Creates a for the given executable code block root .

Root syntax node for an executable code block. Semantic model for the syntax tree containing the . Optional cancellation token. Returns null if returns null for the given and . Otherwise, returns a for the executable code block.

Creates a for the given executable code block .

Root operation block, which must have a null parent. Optional cancellation token.

Creates a for the given executable code block .

Root field initializer operation, which must have a null parent. Optional cancellation token.

Creates a for the given executable code block .

Root property initializer operation, which must have a null parent. Optional cancellation token.

Creates a for the given executable code block .

Root parameter initializer operation, which must have a null parent. Optional cancellation token.

Creates a for the given executable code block .

Root attribute operation, which must have a null parent. Optional cancellation token.

Creates a for the given executable code block .

Root constructor body operation, which must have a null parent. Optional cancellation token.

Creates a for the given executable code block .

Root method body operation, which must have a null parent. Optional cancellation token.

Original operation, representing an executable code block, from which this control flow graph was generated. Note that in the control flow graph are not in the same operation tree as the original operation.

Optional parent control flow graph for this graph. Non-null for a control flow graph generated for a local function or a lambda. Null otherwise.

Basic blocks for the control flow graph.

Root () region for the graph.

Local functions declared within .

Creates a control flow graph for the given .

Some basic concepts: - Basic blocks are sequences of statements/operations with no branching. The only branching allowed is at the end of the basic block. - Regions group blocks together and represent the lifetime of locals and captures, loosely similar to scopes in C#. There are different kinds of regions, . - converts values on the stack into captures. - Error scenarios from initial binding need to be handled.

Represents the stack s of a tree of conditional accesses. The top of the stack is the deepest node, and except in error conditions it should contain a that will be visited when visiting this node. This is the basic recursion that ensures that the operations are visited at the correct time.

The basic block to branch to if the top of the stack is null.

This structure is meant to capture a snapshot of the state that is needed to build graphs for lambdas and local functions.

Holds the current object being initialized if we're visiting an object initializer. Or the current anonymous type object being initialized if we're visiting an anonymous type object initializer. Or the target of a VB With statement.

Do a pass to eliminate blocks without statements that can be merged with predecessor(s) and to eliminate regions that can be merged with parents.

Merge content of into its enclosing region and free it.

Do a pass to eliminate blocks without statements that can be merged with predecessor(s). Returns true if any blocks were eliminated

Deal with labeled blocks that were not added to the graph because labels were never found

Either visits a single operation, or a using and all subsequent statements

The statement to visit All statements in the block containing this node The current statement being visited in True if this visited all of the statements The operation being visited is not necessarily equal to statements[startIndex]. When traversing down a set of labels, we set operation to the label.Operation and recurse, but statements[startIndex] still refers to the original parent label as we haven't actually moved down the original statement list

This class captures information about beginning of stack frame and corresponding if one was allocated to track s used by the stack spilling, etc. Do not create instances of this type manually, use helper instead. Also, do not assign explicitly. Let the builder machinery do this when appropriate.

This function does not change the current region. The stack should be spilled before calling it.

Returns converted test expression. Caller is responsible for spilling the stack and pushing a stack frame before calling this helper.

Recursively push nexted values onto the stack for visiting

Recursively pop nested tuple values off the stack after visiting

Holds the current object instance being initialized if we're visiting an object initializer.

Holds the current anonymous type instance being initialized if we're visiting an anonymous object initializer.

Holds the captured values for initialized anonymous type properties in an anonymous object initializer.

Gets or creates a control flow graph for the given defined in the given or any of it's parent control flow graphs.

Encapsulates information about regions of s in a . Regions can overlap, but never cross each other boundaries.

Region's kind

Enclosing region. Null for

Target exception type for , ,

Ordinal () of the first within the region.

Ordinal () of the last within the region.

Regions nested within this region.

Locals for which this region represent the life-time.

Local functions declared within the region.

Capture Ids used for intermediate results within the region.

Defines kinds of regions that can be present in a

A root region encapsulating all s in a

Region with the only purpose to represent the life-time of locals, intermediate results, and nested methods (local functions, lambdas). The lifetime of a local variable is the portion of program execution during which storage is guaranteed to be reserved for it. The lifetime of a nested method is the portion of program execution within which the method can be referenced. The lifetime of an intermediate result (capture) is the portion of program execution within which the result can be referenced.

Region representing a try region. For example,

Region representing

Region representing a union of a and the corresponding catch regions. Doesn't contain any s directly.

Region representing a union of a and all corresponding catch and regions. Doesn't contain any s directly.

Region representing

Region representing a union of a and corresponding finally region. Doesn't contain any s directly. An that has a set of and a at the same time is mapped to a region with region inside its region.

Region representing the initialization for a VB Static local variable. This region will only be executed the first time a function is called.

Region representing erroneous block of code that is unreachable from the entry block.

All of the kinds of operations, including statements and expressions.

Indicates an for a construct that is not implemented yet.

Indicates an .

Indicates an . This is further differentiated by .

Indicates an .

Indicates an . This has yield break semantics.

Indicates an .

Indicates an . This has yield return semantics.

Indicates an .

Indicates an . Use instead.

Indicates an .

Indicates an . Use instead.

Indicates an .

Indicates an . This is used as an increment operator

Indicates an .

Indicates an . This is used as a decrement operator

Indicates an .

Indicates an . This is further differentiated by .

Indicates an .

Indicates an . Use instead.

Indicates an .

Indicates an . Use instead.

Indicates an .

Indicates an . Use instead.

Indicates an .

Indicates an . This append is of a literal component

Indicates an . This append is of an interpolation component

Indicates an . This append is invalid

Indicates an .

Specifies the Ids of types that are expected to be defined in core library. Unlike ids in enum, these ids are not meant for public consumption and are meant for internal usage in compilers.

Indicates that the type is from the COR library.

Check for this special type cannot be used to find the "canonical" definition of since it is fully legal for it to come from sources other than the COR library, e.g. from `System.Memory` package. The should be used for that purpose instead This entry mostly exists so that compiler can tell this type apart when resolving other members of the COR library

Indicates that the type is from the COR library.

Check for this special type cannot be used to find the "canonical" definition of since it is fully legal for it to come from sources other than the COR library. The should be used for that purpose instead This entry mostly exists so that compiler can tell this type apart when resolving other members of the COR library

Indicates that the type is from the COR library.

This item should be kept last and it doesn't represent any specific type.

Cache with a fixed size that evicts the least recently used members. Thread-safe.

Create cache from an array. The cache capacity will be the size of the array. All elements of the array will be added to the cache. If any duplicate keys are found in the array a will be thrown.

For testing. Very expensive.

Expects non-empty cache. Does not lock.

Doesn't lock.

A pre-created delegate to assign to if needed.

Dumps the stack trace of the exception and the handler to the console. This is useful for debugging unit tests that hit a fatal 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.

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

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

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

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

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

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

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

to avoid catching the exception.

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

to avoid catching the exception.

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

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

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

True to catch the exception.

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

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

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

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

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

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

A Span-compatible version of .

Very cheap trivial comparer that never matches the keys, should only be used in empty dictionaries.

Defines diagnostic info for Roslyn experimental APIs.

Ensures that the remaining stack space is large enough to execute the average function.

how many times the calling function has recursed The available stack space is insufficient to execute the average function.

Represents an optional bool as a single byte.

Used to devirtualize ConcurrentDictionary for EqualityComparer{T}.Default and ReferenceEquals This type is to enable fast-path devirtualization in the Jit. Dictionary{K, V}, HashTable{T} and ConcurrentDictionary{K, V} will devirtualize (and potentially inline) the IEquatable{T}.Equals method for a struct when the Comparer is unspecified in .NET Core, .NET 5; whereas specifying a Comparer will make .Equals and GetHashcode slower interface calls.

The result of

This indicates that friend access should be granted.

This indicates that friend access should be granted for the purposes of error recovery, but the program is wrong. That's because this indicates that a strong-named assembly has referred to a weak-named assembly which has extended friend access to the strong-named assembly. This will ultimately result in an error because strong-named assemblies may not refer to weak-named assemblies. In Roslyn we give a new error, CS7029, before emit time. In the dev10 compiler we error at emit time.

This indicates that friend access should not be granted because the other assembly grants friend access to a strong-named assembly, and either this assembly is weak-named, or it is strong-named and the names don't match.

This indicates that friend access should not be granted because the other assembly does not name this assembly as a friend in any way whatsoever.

Structure that describes a member of a type.

Id/token of containing type, usually value from some enum. For example from SpecialType enum. I am not using SpecialType as the type for this field because VB runtime types are not part of SpecialType. So, the implication is that any type ids we use outside of the SpecialType (either for the VB runtime classes, or types like System.Task etc.) will need to use IDs that are all mutually disjoint.

Signature of the field or method, similar to metadata signature, but with the following exceptions: 1) Truncated on the left, for methods starts at [ParamCount], for fields at [Type] 2) Type tokens are not compressed 3) BOOLEAN | CHAR | I1 | U1 | I2 | U2 | I4 | U4 | I8 | U8 | R4 | R8 | I | U | Void types are encoded by using VALUETYPE+typeId notation. 4) array bounds are not included. 5) modifiers are not included. 6) (CLASS | VALUETYPE) are omitted after GENERICINST

Applicable only to properties and methods, throws otherwise.

The type Id may be: (1) encoded in a single byte (for types below 255) (2) encoded in two bytes (255 + extension byte) for types below 512

Read a type Id from the stream and copy it into the builder. This may copy one or two bytes depending on the first one.

Helper class to match signatures in format of MemberDescriptor.Signature to members.

Returns true if signature matches signature of the field. Signature should be in format described in MemberDescriptor.

Returns true if signature matches signature of the property. Signature should be in format described in MemberDescriptor.

Returns true if signature matches signature of the method. Signature should be in format described in MemberDescriptor.

Does pretty much the same thing as MetadataDecoder.DecodeType only instead of producing a type symbol it compares encoded type to the target. Signature should be in format described in MemberDescriptor.

Read a type Id from the signature. This may consume one or two bytes, and therefore increment the position correspondingly.

Should return null in case of error.

Should only accept Pointer types. Should return null in case of error.

Should return null in case of error.

Should only accept multi-dimensional arrays.

Should only accept multi-dimensional arrays. Should return null in case of error.

If the encoded type is invalid. An exception from metadata reader. If the encoded type is invalid. An exception from metadata reader. If the encoded type is invalid. An exception from metadata reader. An exception from metadata reader. If the encoded type is invalid. An exception from metadata reader. If the encoded local variable type is invalid. An exception from metadata reader. If the encoded local variable type is invalid. An exception from metadata reader.

Used to decode signatures of local constants returned by SymReader.

Returns the local info for all locals indexed by slot.

If the encoded parameter type is invalid. An exception from metadata reader.

Decodes attribute argument type from attribute blob (called FieldOrPropType in the spec).

If the encoded argument type is invalid. An exception from metadata reader. If the encoded attribute argument is invalid. An exception from metadata reader. If the encoded attribute argument is invalid. An exception from metadata reader. If the encoded attribute argument is invalid. An exception from metadata reader. If the given is invalid. An exception from metadata reader. If the encoded named argument is invalid. An exception from metadata reader. An exception from metadata reader. An exception from metadata reader. An exception from metadata reader. An exception from metadata reader. An exception from metadata reader.

Find the methods that a given method explicitly overrides.

Methods may be on class or interfaces. Containing classes/interfaces will be supertypes of the implementing type. TypeDef handle of the implementing type. MethodDef handle of the implementing method. The type symbol for the implementing type. Array of implemented methods.

Search for the corresponding to the given MethodDef token. Search amongst the supertypes (classes and interfaces) of a designated type.

Generally, the type will be a type that explicitly implements an interface and the method will be the implemented method (i.e. on the interface). TypeDef token of the type from which the search should begin. MethodDef token of the target method. Corresponding or null, if none is found.

Enqueue the interfaces implemented and the type extended by a given TypeDef.

Queue of TypeDefs to search. Queue of TypeSymbols (representing typeRefs to search). Handle of the TypeDef for which we want to enqueue supertypes. An exception from metadata reader.

Helper method for enqueuing a type token in the right queue. Def -> typeDefsToSearch Ref -> typeSymbolsToSearch null -> neither

Enqueue the interfaces implemented and the type extended by a given TypeDef.

Queue of TypeDefs to search. Queue of TypeSymbols (representing typeRefs to search). Symbol for which we want to enqueue supertypes.

Enqueue the given type as either a def or a ref.

Queue of TypeDefs to search. Queue of TypeSymbols (representing typeRefs to search). Symbol to enqueue.

Search the members of a TypeSymbol to find the one that matches a given MethodDef token.

Type to search for method. MethodDef handle of the method to find. The corresponding MethodSymbol or null.

Search the members of a TypeSymbol to find the one that matches a given FieldDef token.

Type to search for field. FieldDef handle of the field to find. The corresponding FieldSymbol or null.

Given a MemberRef token for a method, we can find a corresponding MethodSymbol by searching for the name and signature.

A MemberRef token for a method. Scope the search to supertypes of the implementing type. True to only return method symbols, null if the token resolves to a field. The corresponding MethodSymbol or null.

Given a method symbol, return the MethodDef token, if it is defined in this module, or a nil token, otherwise.

The method symbol for which to return a MethodDef token. A MethodDef token or nil.

Returns a symbol that given token resolves to or null of the token represents an entity that isn't represented by a symbol, such as vararg MemberRef.

Given a MemberRef token, return the TypeSymbol for its Class field.

Checks whether signatures match where the signatures are either from a property and an accessor or two accessors. When comparing a property or getter to setter, the setter signature must be the second argument and 'comparingToSetter' must be true.

Signature of the property containing the accessor, or the getter (type, then parameters). Signature of the accessor when comparing property and accessor, or the setter when comparing getter and setter (return type and then parameters). True when comparing a property or getter to a setter, false otherwise. True if differences in IsByRef for parameters should be treated as significant. True if differences in return type (or value parameter for setter) should be treated as significant. True if the accessor signature is appropriate for the containing property.

Check whether an event accessor has an appropriate signature.

Type of the event containing the accessor. Signature of the accessor (return type and then parameters). True if the accessor signature is appropriate for the containing event.

Rank equal 0 is used to denote an SzArray, rank equal 1 denotes multi-dimensional array of rank 1.

Decodes a serialized type name in its canonical form. The canonical name is its full type name, followed optionally by the assembly where it is defined, its version, culture and public key token. If the assembly name is omitted, the type name is in the current assembly otherwise it is in the referenced assembly. The full type name is the fully qualified metadata type name.

Decodes a type name. A type name is a string which is terminated by the end of the string or one of the delimiters '+', ',', '[', ']'. '+' separates nested classes. '[' and ']' enclosed generic type arguments. ',' separates types.

Decodes a generic name. This is a type name followed optionally by a type parameter count

Rank equal 0 is used to denote an SzArray, rank equal 1 denotes multi-dimensional array of rank 1.

An ImmutableArray representing the single string "System"

Calculates information about types and namespaces immediately contained within a namespace.

Is current namespace a global namespace? Length of the fully-qualified name of this namespace. The sequence of groups of TypeDef row ids for types contained within the namespace, recursively including those from nested namespaces. The row ids must be grouped by the fully-qualified namespace name in case-sensitive manner. Key of each IGrouping is a fully-qualified namespace name, which starts with the name of this namespace. There could be multiple groups for each fully-qualified namespace name. The groups must be sorted by the keys in a manner consistent with comparer passed in as nameComparer. Therefore, all types immediately contained within THIS namespace, if any, must be in several IGrouping at the very beginning of the sequence. Equality comparer to compare namespace names. Output parameter, never null: A sequence of groups of TypeDef row ids for types immediately contained within this namespace. Output parameter, never null: A sequence with information about namespaces immediately contained within this namespace. For each pair: Key - contains simple name of a child namespace. Value - contains a sequence similar to the one passed to this function, but calculated for the child namespace.

Extract a simple name of a top level child namespace from potentially qualified namespace name.

Parent namespace name length plus the dot. Fully qualified namespace name. Simple name of a top level child namespace, the left-most name following parent namespace name in the fully qualified name.

Determines whether given string can be used as a non-empty metadata identifier (a NUL-terminated UTF-8 string).

True if the string doesn't contain incomplete surrogates.

Checks that the specified name is a valid metadata String and a file name. The specification isn't entirely consistent and complete but it mentions: 22.19.2: "Name shall index a non-empty string in the String heap. It shall be in the format {filename}.{extension} (e.g., 'goo.dll', but not 'c:\utils\goo.dll')." 22.30.2: "The format of Name is {file name}.{file extension} with no path or drive letter; on POSIX-compliant systems Name contains no colon, no forward-slash, no backslash." As Microsoft specific constraint. A reasonable restriction seems to be a valid UTF-8 non-empty string that doesn't contain '\0', '\', '/', ':' characters.

Determine if the given namespace and type names combine to produce the given fully qualified name.

The namespace part of the split name. The type name part of the split name. The fully qualified name to compare with. true if the combination of and equals the fully-qualified name given by

Given an input string changes it to be acceptable as a part of a type name.

Specifies what symbols to import from metadata.

Only import public and protected symbols.

Import public, protected and internal symbols.

Import all symbols.

An exception from metadata reader. An exception from metadata reader. An exception from metadata reader. An exception from metadata reader. An exception from metadata reader.

Helper structure to encapsulate/cache various information about metadata name of a type and name resolution options. Also, allows us to stop using strings in the APIs that accept only metadata names, making usage of them less bug prone.

Full metadata name of a type, includes namespace name for top level types.

Namespace name for top level types.

version of . Preferred when possible to avoid the copy of the portion of used for .

Name of the type without namespace prefix, but possibly with generic arity mangling present.

version of . Preferred when possible to avoid the copy of the portion of used for .

Name of the type without namespace prefix and without generic arity mangling.

Arity of the type inferred based on the name mangling. It doesn't have to match the actual arity of the type.

While resolving the name, consider only types with this arity. (-1) means allow any arity. If forcedArity >= 0 and useCLSCompliantNameArityEncoding, lookup may fail because forcedArity doesn't match the one encoded in the name.

While resolving the name, consider only types following CLS-compliant generic type names and arity encoding (ECMA-335, section 10.7.2). I.e. arity is inferred from the name and matching type must have the same emitted name and arity. TODO: PERF: Encode this field elsewhere to save 4 bytes

Individual parts of qualified namespace name.

version of . Preferred when possible to avoid the copies of the portions of used for .

Full metadata name of a type, includes namespace name for top level types.

Namespace name for top level types, empty string for nested types.

Name of the type without namespace prefix, but possibly with generic arity mangling present.

Name of the type without namespace prefix and without generic arity mangling.

Arity of the type inferred based on the name mangling. It doesn't have to match the actual arity of the type.

Does name include arity mangling suffix.

While resolving the name, consider only types with this arity. (-1) means allow any arity. If ForcedArity >= 0 and UseCLSCompliantNameArityEncoding, lookup may fail because ForcedArity doesn't match the one encoded in the name.

Individual parts of qualified namespace name.

A digest of MetadataTypeName's fully qualified name which can be used as the key in a dictionary

Returns true if the field should be imported. Visibility and the value of are considered

Returns true if the flags represent a field that should be imported. Visibility and the value of are considered

Returns true if the method should be imported. Returns false for private methods that are not explicit interface implementations. For other methods, visibility and the value of are considered.

Returns 0 if method name doesn't represent a v-table gap. Otherwise, returns the gap size.

All assemblies this assembly references.

A concatenation of assemblies referenced by each module in the order they are listed in .

The number of assemblies referenced by each module in .

Assembly identity read from Assembly table, or null if the table is empty.

Using for atomicity.

We need to store reference to the assembly metadata to keep the metadata alive while symbols have reference to PEAssembly.

A set of helpers for extracting elements from metadata. This type is not responsible for managing the underlying storage backing the PE image.

We need to store reference to the module metadata to keep the metadata alive while symbols have reference to PEModule.

This is a tuple for optimization purposes. In valid cases, we need to store only one assembly index per type. However, if we found more than one, we keep a second one as well to use it for error reporting. We use -1 in case there was no forward.

Case-insensitive version of , only populated if case-insensitive search is requested. We only keep the first instance of a type name, regardless of case, as this is only used for error recovery purposes in VB.

Using as a type for atomicity.

If bitmap is not null, each bit indicates whether a TypeDef with corresponding RowId has been checked if it is a NoPia local type. If the bit is 1, local type will have an entry in m_lazyTypeDefToTypeIdentifierMap.

For each TypeDef that has 1 in m_lazyNoPiaLocalTypeCheckBitMap, this map stores corresponding TypeIdentifier AttributeInfo.

Target architecture of the machine.

Indicates that this PE file makes Win32 calls. See CorPEKind.pe32BitRequired for more information (http://msdn.microsoft.com/en-us/library/ms230275.aspx).

An exception from metadata reader.

Returns the names of linked managed modules.

An exception from metadata reader.

Returns names of referenced modules.

The function groups types defined in the module by their fully-qualified namespace name. The case-sensitivity of the grouping depends upon the provided StringComparer. The sequence is sorted by name by using provided comparer. Therefore, if there are multiple groups for a namespace name (e.g. because they differ in case), the groups are going to be adjacent to each other. Empty string is used as namespace name for types in the Global namespace. Therefore, all types in the Global namespace, if any, should be in the first group (assuming a reasonable StringComparer).

Comparer to sort the groups. A sorted list of TypeDef row ids, grouped by fully-qualified namespace name. An exception from metadata reader.

Groups together the RowIds of types in a given namespaces. The types considered are those defined in this module.

An exception from metadata reader.

Supplements the namespace-to-RowIDs map with the namespaces of forwarded types. These types will not have associated row IDs (represented as null, for efficiency). These namespaces are important because we want lookups of missing forwarded types to succeed far enough that we can actually find the type forwarder and provide information about the target assembly. For example, consider the following forwarded type: .class extern forwarder Namespace.Type {} If this type is referenced in source as "Namespace.Type", then dev10 reports error CS1070: The type name 'Namespace.Name' could not be found. This type has been forwarded to assembly 'pe2, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null'. Consider adding a reference to that assembly. If we did not include "Namespace" as a child of the global namespace of this module (the forwarding module), then Roslyn would report that the type "Namespace" was not found and say nothing about "Name" (because of the diagnostic already attached to the qualifier).

An exception from metadata reader. An exception from metadata reader. An exception from metadata reader.

Returns a collection of interfaces implemented by given type.

Indicates whether the first attribute should be prioritized over the second one. Same order of priority as

Find the MemberNotNull attribute(s) and extract the list of referenced member names

Find the MemberNotNullWhen attribute(s) and extract the list of referenced member names

Gets the well-known optional named properties on ObsoleteAttribute, if present. Both 'diagnosticId' and 'urlFormat' may be present, or only one, or neither.

Failure to find any of these properties does not imply failure to decode the ObsoleteAttribute, so we don't return a value indicating success or failure. An exception from metadata reader.

Determine if custom attribute application is NoPia TypeIdentifier.

An index of the target constructor signature in signaturesOfTypeIdentifierAttribute array, -1 if this is not NoPia TypeIdentifier.

Determines if a custom attribute matches a namespace and name.

Handle of the custom attribute. The custom attribute's namespace in metadata format (case sensitive) The custom attribute's type name in metadata format (case sensitive) Constructor of the custom attribute. Should case be ignored for name comparison? true if match is found

Determines if a custom attribute matches a namespace and name.

The metadata reader. Handle of the custom attribute. The custom attribute's namespace in metadata format (case sensitive) The custom attribute's type name in metadata format (case sensitive) Constructor of the custom attribute. Should case be ignored for name comparison? true if match is found

Returns MetadataToken for assembly ref matching name

The assembly name in metadata format (case sensitive) Matching assembly ref token or nil (0)

Returns MetadataToken for type ref matching resolution scope and name

The resolution scope token The namespace name in metadata format (case sensitive) The type name in metadata format (case sensitive) Matching type ref token or nil (0) An exception from metadata reader.

Determine if custom attribute matches the target attribute.

Handle of the custom attribute. The attribute to match. An index of the target constructor signature in signatures array, -1 if this is not the target attribute.

Determine if custom attribute matches the target attribute.

The metadata reader. Handle of the custom attribute. The attribute to match. The custom attribute matched the target attribute namespace and type. An index of the target constructor signature in signatures array, -1 if this is not the target attribute.

Given a token for a constructor, return the token for the constructor's type and the blob containing the constructor's signature.

True if the function successfully returns the type and signature.

Given a token for a constructor, return the token for the constructor's type and the blob containing the constructor's signature.

True if the function successfully returns the type and signature.

Given a token for a type, return the type's name and namespace. Only works for top level types. namespaceHandle will be NamespaceDefinitionHandle for defs and StringHandle for refs.

True if the function successfully returns the name and namespace.

Given a token for a type, return the type's name and namespace. Only works for top level types. namespaceHandle will be NamespaceDefinitionHandle for defs and StringHandle for refs.

True if the function successfully returns the name and namespace.

For testing purposes only!!!

An exception from metadata reader. An exception from metadata reader. An exception from metadata reader. An exception from metadata reader. An exception from metadata reader. An exception from metadata reader. An exception from metadata reader. An exception from metadata reader. An exception from metadata reader. An exception from metadata reader. An exception from metadata reader. An exception from metadata reader. An exception from metadata reader. An exception from metadata reader. An exception from metadata reader. An exception from metadata reader. An exception from metadata reader. An exception from metadata reader. An exception from metadata reader. An exception from metadata reader. An exception from metadata reader. An exception from metadata reader. An exception from metadata reader. An exception from metadata reader. An exception from metadata reader. An exception from metadata reader. An exception from metadata reader. An exception from metadata reader. An exception from metadata reader. An exception from metadata reader. An exception from metadata reader. An exception from metadata reader. An exception from metadata reader. An exception from metadata reader. An exception from metadata reader. An exception from metadata reader. An exception from metadata reader. An exception from metadata reader. An exception from metadata reader. An exception from metadata reader.

Returns true if method IL can be retrieved from the module.

Returns true if the full image of the module is available.

Invalid metadata.

Produce unbound generic type symbol if the type is a generic type.

Produce constructed type symbol.

Symbol for generic type. Generic type arguments, including those for containing types. Flags for arguments. Each item indicates whether corresponding argument refers to NoPia local types.

Extracts information from TypeDef flags. Returns 0 if the value is invalid.

Lookup a type defined in this module.

Lookup a type defined in referenced assembly.

Given the identity of an assembly referenced by this module, finds the index of that assembly in the list of assemblies referenced by the current module.

Represents an identity of an assembly as defined by CLI metadata specification.

May represent assembly definition or assembly reference identity.

Represents an identity of an assembly as defined by CLI metadata specification.

May represent assembly definition or assembly reference identity.

Constructs an from its constituent parts.

The simple name of the assembly. The version of the assembly. The name of the culture to associate with the assembly. Specify null, , or "neutral" (any casing) to represent . The name can be an arbitrary string that doesn't contain NUL character, the legality of the culture name is not validated. The public key or public key token of the assembly. Indicates whether represents a public key. Indicates whether the assembly is retargetable. Specifies the binding model for how this object will be treated in comparisons. If is null, empty or contains a NUL character. If contains a NUL character. is not a value of the enumeration. contains values that are not greater than or equal to zero and less than or equal to ushort.MaxValue. is true and is not set. is false and contains a value that is not the size of a public key token, 8 bytes.

The simple name of the assembly.

The version of the assembly.

The culture name of the assembly, or empty if the culture is neutral.

The AssemblyNameFlags.

Specifies assembly binding model for the assembly definition or reference; that is how assembly references are matched to assembly definitions.

True if the assembly identity includes full public key.

Full public key or empty.

Low 8 bytes of SHA1 hash of the public key, or empty.

True if the assembly identity has a strong name, ie. either a full public key or a token.

Gets the value which specifies if the assembly is retargetable.

Determines whether two instances are equal.

The operand appearing on the left side of the operator. The operand appearing on the right side of the operator.

Determines whether two instances are not equal.

The operand appearing on the left side of the operator. The operand appearing on the right side of the operator.

Determines whether the specified instance is equal to the current instance.

The object to be compared with the current instance.

Determines whether the specified instance is equal to the current instance.

The object to be compared with the current instance.

Returns the hash code for the current instance.

Returns true (false) if specified assembly identities are (not) equal regardless of unification, retargeting or other assembly binding policies. Returns null if these policies must be consulted to determine name equivalence.

Retrieves assembly definition identity from given runtime assembly.

The runtime assembly. Assembly definition identity. is null.

Returns the display name of the assembly identity.

True if the full public key should be included in the name. Otherwise public key token is used. The display name. Characters ',', '=', '"', '\'', '\' occurring in the simple name are escaped by backslash in the display name. Any character '\t' is replaced by two characters '\' and 't', Any character '\n' is replaced by two characters '\' and 'n', Any character '\r' is replaced by two characters '\' and 'r', The assembly name in the display name is enclosed in double quotes if it starts or ends with a whitespace character (' ', '\t', '\r', '\n').

Returns the display name of the current instance.

Perf: ETW traces show 2%+ of all allocations parsing assembly identity names. This is due to how large these strings can be (600+ characters in some cases), and how many substrings are continually produced as the string is broken up into the pieces needed by AssemblyIdentity. The capacity of 1024 was picked as around 700 unique strings were found in a solution the size of Roslyn.sln. So this seems like a reasonable starting point for a large solution. This cache takes up around 240k in memory, but ends up saving >80MB of garbage over typing even a few characters. And, of course, that savings just grows over the lifetime of a session this is hosted within.

Parses display name filling defaults for any basic properties that are missing.

Display name. A full assembly identity. Parts of the assembly identity that were specified in the display name, or 0 if the parsing failed. True if display name parsed correctly. The simple name has to be non-empty. A partially specified version might be missing build and/or revision number. The default value for these is 65535. The default culture is neutral ( is . If neither public key nor token is specified the identity is considered weak. is null.

Compares assembly identities. Derived types may implement platform specific unification and portability policies.

A set of possible outcomes of comparison.

Reference doesn't match definition.

Strongly named reference matches strongly named definition (strong identity is identity with public key or token), Or weak reference matches weak definition.

Reference matches definition except for version (reference version is lower or higher than definition version).

Compares assembly reference name (possibly partial) with definition identity.

Partial or full assembly display name. Full assembly display name. True if the reference name matches the definition identity.

Compares assembly reference identity with definition identity.

Reference assembly identity. Full assembly display name. True if the reference identity matches the definition identity.

Compares reference assembly identity with definition identity and returns their relationship.

Reference identity. Definition identity.

Implements a map from an assembly identity to a value. The map allows to look up the value by an identity that either exactly matches the original identity key, or corresponds to a key with the lowest version among identities with higher version than the requested identity key.

Represents an immutable snapshot of assembly CLI metadata.

Factory that provides the for additional modules (other than ) of the assembly. Shall only throw or . Null of all modules were specified at construction time.

Modules the was created with, in case they are eagerly allocated.

Cached assembly symbols.

Guarded by .

Creates a single-module assembly.

Manifest module image. is null.

Creates a single-module assembly.

Manifest module image. is null. The PE image format is invalid.

Creates a single-module assembly.

Manifest module PE image stream. False to close the stream upon disposal of the metadata. The PE image format is invalid.

Creates a single-module assembly.

Manifest module PE image stream. False to close the stream upon disposal of the metadata. The PE image format is invalid.

Finds all modules of an assembly on a specified path and builds an instance of that represents them.

The full path to the assembly on disk. is null. is invalid. Error reading file . See for details. Reading from a file path is not supported by the platform.

Creates a single-module assembly.

Manifest module. This object disposes it when it is itself disposed.

Creates a multi-module assembly.

Modules comprising the assembly. The first module is the manifest module of the assembly. This object disposes the elements of it when it is itself . is default value. contains null elements. is empty or contains a module that doesn't own its image (was created via ).

Creates a multi-module assembly.

Creates a shallow copy of contained modules and wraps them into a new instance of .

The resulting copy shares the metadata images and metadata information read from them with the original. It doesn't own the underlying metadata images and is not responsible for its disposal. This is used, for example, when a metadata cache needs to return the cached metadata to its users while keeping the ownership of the cached metadata object.

Modules comprising this assembly. The first module is the manifest module.

The PE image format is invalid. IO error reading the metadata. See for details. The object has been disposed. The PE image format is invalid. IO error while reading the metadata. See for details. The object has been disposed. The PE image format is invalid. IO error while reading the metadata. See for details. The object has been disposed.

Disposes all modules contained in the assembly.

Checks if the first module has a single row in Assembly table and that all other modules have none.

The PE image format is invalid. IO error reading the metadata. See for details. The object has been disposed.

Returns the metadata kind.

Creates a reference to the assembly metadata.

Provider of XML documentation comments for the metadata symbols contained in the module. Aliases that can be used to refer to the assembly from source code (see "extern alias" directive in C#). True to embed interop types from the referenced assembly to the referencing compilation. Must be false for a module. Path describing the location of the metadata, or null if the metadata have no location. Display string used in error messages to identity the reference. A reference to the assembly metadata.

Reference to another C# or VB compilation.

Returns an instance of the reference with specified aliases.

The new aliases for the reference. Alias is invalid for the metadata kind.

Returns an instance of the reference with specified aliases.

The new aliases for the reference. Alias is invalid for the metadata kind.

Returns an instance of the reference with specified interop types embedding.

The new value for . Interop types can't be embedded from modules.

Returns an instance of the reference with specified properties, or this instance if properties haven't changed.

The new properties for the reference. Specified values not valid for this reference.

An Id that can be used to identify a metadata instance. If two metadata instances have the same id then they are guaranteed to have the same content. If two metadata instances have different ids, then the contents may or may not be the same. As such, the id is useful as a key in a cache when a client wants to share data for a metadata reference as long as it has not changed.

Represents immutable assembly or module CLI metadata.

The id for this metadata instance. If two metadata instances have the same id, then they have the same content. If they have different ids they may or may not have the same content.

Retrieves the for this instance.

Releases any resources associated with this instance.

Creates a copy of this object.

The kind of metadata a PE file image contains.

The PE file is an assembly.

The PE file is a module.

Represents an in-memory Portable-Executable image.

Represents metadata image reference.

Represents a logical location of the image, not the content of the image. The content might change in time. A snapshot is taken when the compiler queries the reference for its metadata.

Path or name used in error messages to identity the reference.

Returns true if this reference is an unresolved reference.