Microsoft.VisualStudio.CodeAnalysis.Phoenix

Base class for an analyzer that can examine a contract function and produce summary info for use by later analysis.

The type of the summary object produced by this analyzer for function call preconditions. The type of the summary object produced by this analyzer for function postconditions.

Default constructor for ContractAnalyzer

Override this method to summarize information known about the program at the point just before a function call.

The CallInstruction of the call whose preconditions are to be summarized. An object containing the summary of the call's preconditions. This may be null.

Override this method to summarize information known about the program at the point just before a function return.

The FunctionUnit of the function whose preconditions are to be summarized. An object containing the summary of the function's preconditions. This may be null.

Base class for an analyzer that can examine a contract function and produce summary info for use by later analysis.

This class serves as a base class for all contract assertion classes. Contract creators attach ContractAssertion objects to label operands that lead to a control flow graph edge that, if executed, represents a failed contract. Rules that fire on contract violations examine the set of ContractAssertions on a edge as part of deciding whether or not to fire a warning.

Default constructor for ContractAssertion.

Sets the list of ContractAssertion objects associated with the specified LabelOperand.

The label operand whose contract assertions are to be set. Kind of assertion this label represents. A variable-length list of ContractAssertion objects to be associated with the specified LabelOperand. This method may only be called once for any given LabelOperand.

Specifies the kind of contract that an assertion represents.

The contract assertion is from a user-written assertion within a function body.

The contract assertion is a function precondition.

The contract assertion is a function postcondition.

The contract assertion is a class invariant.

The contract assertion is a loop invariant.

Provides information about a contract function.

The CallInstruction that calls the real implementation of the function whose contract is being described.

The symbol for the function whose contract is being described.

The FunctionUnit containing the IR for the contract function.

The label where any precondition code is to be inserted. This label is after the EnterFunction instruction, before the call instruction.

The label where any postcondition code is to be inserted. This label is after the call instruction, before the return instruction.

The list of symbols representing the parameters of the function. The symbols in this list are in the same order as the parameters in the function's type.

The return instruction that returns from the contract.

The symbol representing the return value of the function. This will be null if the function has a void return.

A label that marks the location of an Unreached instruction. Contract code can branch to this label to denote conditions under which the contract is not satisfied.

Populate the specified FunctionUnit with IR representing the minimal contract for the function.

FunctionSymbol whose contract is to be populated. Contract FunctionUnit to be populated. A ContractInfo object describing the contents of the contract.

Provides services related to contracts, including function preconditions and postconditions.

Gets the precondition summary object previously computed by the specified analyzer for the specified function.

The type of object used by the analyzer to summarize the preconditions of a function call. The type of object used by the analyzer to summarize the postconditions of a function. The analyzer whose summary information is to be retrieved. The EnterFunction instruction of the function being called. The object that summarizes the preconditions for the function.

Gets the postcondition summary object previously computed by the specified analyzer for the specified function call..

The type of object used by the analyzer to summarize the preconditions of a function call. The type of object used by the analyzer to summarize the postconditions of a function. The analyzer whose summary information is to be retrieved. The CallInstruction of the function being called. The object that summarizes the postconditions for the function call.

Represents the context in which a function contract (a precondition or a postcondition) is being evaluated.

The FunctionSymbol of the function whose contract is being evaluated.

The SourceContext representing the point in the source code at which the contract is being evaluated.

This class represents a contract assertion that requires that a particular expression of pointer type be null, or that the expression be non-null.

The LabelOperand to which the NullPointerContractAssertion is attached must be the operand named 'FalseLabel' in an IR sequence as follows: t123 = Compare(CC) p.up32->void, 0.up32->void = ConditionalBranch(True) t123, TrueLabel, FalseLabel The condition code (CC) of the Compare instruction must be either EQ or NE.

Inject an assertion that a specified operand is (or is not) equal to null.

Kind of assertion to be injected. ContractInfo object describing the contract function moduleUnit into which the assertion is to be injected. Operand whose nullness is to be asserted. Condition code specifying how the operand must be compared with null. This must be either EQ or NE. Instruction in the contract funciton moduleUnit after which to insert the assertion.

Determine if a list of ContractAssertion objects contains at least one NullPointerContractAssertion.

The list of ContractAssertion objects to check. 'true' if the list contains at least on NullPointerContractAssertion object, 'false' otherwise.

Represents the context in which a function postcondition is being evaluated.

The SourceContext representing the point in the source code at which the contract is being evaluated.

Represents the context in which a function precondition is being evaluated.

The FunctionSymbol of the function that is calling the function with the contract.

The SourceContext representing the point in the source code at which the contract is being evaluated.

Represents the results of a copy analysis on a FunctionUnit.

Composes the states from two competing analysis models. This method is used to determine the most accurate state between analysis results of two different types of analysis trying to determine the correct state for the same cell.

Determine the root operand from which the specified operand was copied.

The operand whose root is to be determined. The root operand from which the input operand was copied.

Represents the results of dead code analysis on a FunctionUnit.

Determine if the specified flow graph edge is dead.

The flow graph edge whose liveness is to be queried. 'true' if the specified edge is dead.

Determine if the specified operand is dead.

The operand whose liveness is to be queried. 'true' if the specified operand is dead.

Represents a state object that the StateLattice tracks. Implementations of this interface must be public!

T should be the concrete class that is implementing IAnalysisState.

Merges the state of another state when the states from two separate control paths meet. For example at a Phi node after an if statement. This method will not change the state of the current state, instead it returns an new instance of a merged state. (This method is usually simply the union or intersection of two states depending on your lattice).

Composes the states from two different analysis models. This method is used to take two determine the most accurate state between analysis results of two different types of analysis trying to determine the correct state for the same cell.

Represents the results of a null pointer analysis.

Get the nullness information for the specified operand.

The operand whose state is to be retrieved. A NullState object holding the state of the specified operand.

Provides information about the contents of parameter arrays.

Get the contents of a parameter array.

The operand used as a param array argument. A list of the operands contained in the parameter array, or null if the contents of the array are not available. An individual operand in the list may be null if no information is known about the value of the parameter at that position.

Represents the results of a value range analysis.

Get the range of possible values for the specified operand.

Operand whose range is to be retrieved. The range of the specified operand.

A RangeAnalysisResult providing a conservative default range for any operand.

Represents the range of possible values of a variable.

The range of possible values for the variable this state is associated with.

Creates a new RangeState with the given bounds.

The minimum possible value The maximum possible value

Creates a new RangeState with the given range.

The range of possible values

Tests if two RangeStates are equal.

the RangeState to compare against True if and only if the ranges represented by the two states are equal.

Represents the results of reachable analysis.

Determine if the specified flow graph edge is unreachable.

The flow graph edge whose reachability is to be queried. 'true' if the specified edge is unreachable.

Determine if the specified basic block is unreachable.

The basic block whose reachability is to be queried. 'true' if the specified basic block is unreachable.

Determine if the specified flow graph edge is unreachable.

The flow graph edge whose reachability is to be queried. 'true' if the specified edge is unreachable.

Determine if the specified basic block is unreachable.

The basic block whose reachability is to be queried. 'true' if the specified basic block is unreachable.

Service that provides the results of copy analysis on a FunctionUnit.

Copy analysis determines which operands are simple copies of another operand.

Provides the results of dead code analysis on a FunctionUnit.

Dead code is code that will be executed, but has no effect on the state of the program. This is different from unreachable code, which will not be executed at all.

Service that provides the EH region graph for a FunctionUnit.

Service that provides the results of nullness analysis on a FunctionUnit.

Service that provides information about the contents of parameter arrays.

Service that provides the results of value range analysis on a FunctionUnit.

Value range analysis computes the range of possible values for each operand.

Creates a new instance of range analysis.

Abstract shared analysis base class for based lattices.

The type that represents the specific state that is being tracked.

Constructor for .

Dataflow analysis service that provides string analysis that tracks the possible contents of strings.

Constructor for .

Type that contains the result of a StringContents dataflow analysis.

Get the for the given operand.

Service providing information about the possible values of strings.

Service that provides the results of writable extent analysis on a FunctionUnit.

Writable extent analysis determines the range of memory locations to which each pointer operand is allowed to write.

Abstract base class for all based s. This class is meant for use with a .

An type that represents the kind of state being represented by this result.

Gets the object for the given .

The to find the state for.

Composes (see ) this result with another result.

It is assumed this parameter is really a .

Represents a cell used by the state lattice.

IMPORTANT: T must be an immutable type. The state lattice makes assumptions that only work if T is immutable. Immutable state type this lattice tracks.

Abstract base class for all based lattices. This class takes care of most of the common code and internal plumbing for lattices. Derived classes should mostly just have to implement the Transfer functions.

The type of this state should track.

Constructor for .

Gets and sets the this lattice will use as an input, for example this is used in the method. The setter will also set the value of the if the input result set contains a result of type . To add other processing when the input result set is set see the

The InputResultSet property will get/set the m_inputResultSet field.

The input analysis result for the lattice. Usually used to pass the result from analysis models to the lattice.

Analysis result that contains the result of the lattice analysis.

Method for use by the simulator to initialize the simulation. End users should not be calling this.

The simulator driving the analysis Lattice.

Method for use only by the simulator to clean up after the simulation. End users should not be calling this.

The simulator driving the analysis Lattice.

Called after each iteration of an optimistic simulation to perform internal checking by the Lattice. This is a Debug only method.

Debug component control for this Lattice.

Gets the state of the given .

A use or definition . If the lattice never calculated a state for the given then the default state is returned. This method never returns null.

Gets the lattice analysis cell for the given . End users should not be calling this method, it is meant for internal lattice use.

A use or definition .

Merges the states of the two given s. This method will call the method to merge the states. By default this is how analysis results are merged at Phi nodes.

The working that represents the final state. The state to merge into the working state. True iff the given state was merged into the first parameter.

Transfer function used to update cells with extra information from the . In most implementations this should be the default transfer function if the does not have special handling for the given .

Updates the given operand with the given state. Clears the state from the operand if state is null.

This method is called whenever we encounter an operand we haven't attached a cell to yet and we don't have a transfer function for the operand's instruction. This method will return an imutable StateAnalysisResult that returns the least defined state for operands.

This method is called when we encounter an operand we haven't attached a cell to yet and we're determining if this lattice should track this operand.

This method is called when a new is set. Use this method to extract out extra analysis results.

that provides a default .

This type has no object state and is a singleton.

This method will return the only instance of .

Gets the default object for the given .

The to find the state for.

Represents the literal or nonliteral state of a string operand in a .

The lattice could not be sure of the state.

The operand does not contain any instances of the specified kind of string.

The operand contains at least one instance of the specified kind of string.

Represents all literal strings and string operands that could possibly be contained in a particular string operand.

IMPORTANT: This class must remain immutable. The makes assumptions that only work if this class is immutable.

Gets the default StringContentsState object.

Default constructor for .

Creates a new with the specified state. If the value of the string literal or nonliteral operand is known then one of the more derived constructors should be used.

Constructor that creates a that will include the given string literalValue in its collection.

Constructor that creates a that will include the given string literalValue in its collection. Sets the to Yes and the to No.

Constructor that creates a that will include the given non literal operand in its collection.

Indicates if this string contains string literals or not.

Indicates if this string contains non literal string operands or not.

Gets a collection of the string literals that could possibly make up the contents of this string .

Gets a collection of the non literal string operands that could possibly make up the contents of this string .

Queries if the value of the string operand might contain the given string literal.

Queries if the value of the string operand might contain the given on literal string operand.

Number of string literals that could possibly make up the contents of this string .

Number of non literal string operands that could possibly make up the contents of this string .

Compares string contents tracked by this state and another state.

Performs the union with this state and the other state and returns a new with the result.

Performs the intersection with this state and the other state and returns a new with the result.

Returns a string representation of .

Base class for analysis results that provide information about the possible values of strings.

Compose this analysis result with another analysis result of the same kind.

Result with which this result is to be composed. An AnalysisResult representing the composition.

Get the string value of this operand, if known.

The operand whose value is to be retrieved. Output parameter to be set to the string value of the operand. 'true' if the string value of the operand is known. If the string value of the operand is not known, will be set to null, and this method will return 'false'.

Constructor for StringValueAnalysisResultComposition.

The first input result. The second input result.

Get the string value of this operand, if known.

Represents the results of a writeable extent analysis.

Gets the writeable extent state of the given operand.

the operand to be analyzed the writeable extent of the given operand

Combines the results of two writeable extent analyses.

the result of the other writeable extent analysis a new analysis result representing the composition of this result and the parameter

Provides the best approximation of a writeable extent when no analysis has been performed or analysis has yielded no results.

Gets the singleton instance of DefaultWritableExtentAnalysisResult.

The singleton instance.

Gets the conservative writeable extent of the given operand.

The operand whose writeable extent is required. A conservative estimate for the writable extent of the operand, or null if the operand is not a buffer.

Represents the writeable extent of a buffer. Writeable extents are represented as the range of valid indeces into that buffer.

The range of valid indeces into the buffer this state is associated with.

Creates a new WriteableExtentState with the given bounds.

the minimum valid index the maximum valid index

Creates a new WriteableExtentState with the given range.

the range of valid indeces

Merge this WritableExtentState with another WritableExtentState.

The other WritableExtentState with which to merge. The merged WritableExtentState. The merged range is the intersection of the two input ranges.

Compose this WritableExtentState with another WritableExtentState.

The other WritableExtentState with which to compose. The composed WritableExtentState. The composed range is the union of the two input ranges.

Tests if two WriteableExtentStates are equal.

the WriteableExtentState to compare against 'true' if the ranges represented by the two states are equal.

Convert the WritableExtentState to a string.

A string representation of the WritableExtentState.

Updates the alias operands on all call instructions based on models.

The function whose call instructions are to be updated.

Checks if the given alias tag exactly overlaps with an existing destination operand on the callInstruction. Multiple destination operands that exactly overlap are not allowed in SSA as it creates an ambiguous definition situation where ssa can not determine the correct definiton to hook a use to.

Abstract base class that represents the results of an analysis on a FunctionUnit. Derive from this class to define your own kind of analysis result (e.g. NullAnalysisResult).

Indicates that this AnalysisResult can also be used to represent another type of analysis result. For example a IntegerRangeAnalysisResult can be converted to a MaxValueIntegerAnalysisResult. Returns null if no convertion exists.

Represents a set of AnalysisResult objects, providing the ability to select individual results based on the type of result.

Construct a new AnalysisResultSet object containing no results.

Construct a new AnalysisResultSet object containing the given results.

AnalysisResultSet to seed the AnalysisResultSet with

Construct a new AnalysisResultSet object containing a single AnalysisResult.

AnalysisResult object to be added to the AnalysisResultSet.

Add a copy of all of the results in another AnalysisResultSet to this AnalysisResultSet.

AnalysisResultSet object containing the results to copy.

Retrieve a result from the AnalysisResultSet, based on the type of the result.

The type of the result to retrieve. An AnalysisResult object of the specified type, representing all of the results of that type that are contained in the AnalysisResultSet, or null if this AnalysisResultSet contains no results of the specified type. If the AnalysisResultSet contains more than one result of the specified type, the AnalysisResult object returned will represent the composition of all of the results of the specified type.

Specifies the set of memory locations that may be accessed by a function call.

Constructor for CallAliasInfo. All tag sets are initialized to their default value of null.

A set of alias tags specifying the complete set of memory locations that may be written to by this call. If this set is null, the function may write to any available memory. An empty set indicates that the function does not write to any visible memory.

A set of alias tags specifying the complete set of memory locations that may be read from by this call. If this set is null, the function may read from any available memory. An empty set indicates that the function does not read from any visible memory.

A set of alias tags specifying specific memory locations that may be modified by this call. Individual alias operands will be inserted for each tag in this set. A null or empty set indicates that no individual tags should be inserted.

A set of alias tags specifying specific memory locations that may be read by this call. Individual alias operands will be inserted for each tag in this set. A null or empty set indicates that no individual tags should be inserted.

Base class for Phoenix-based code analysis hosts.

Constructor for CodeAnalysisHost.

The Discovery object used to provide metadata about the components to be used in the analysis. Flags specifying which optional features this host supports.

Finalizer for CodeAnalysisHost.

Builds the list of passes to run.

This method will call the virtual methods , , and to create the necessary passes. The passes will be created in the order they are to be executed.

Frees any resources owned by the host.

Provides the list of rules to run.

Provides the list of models to run.

Provides the loader used to create instances of components.

Frees any resources owned by the host.

'true' if this object is being disposed as a result of a call to . 'false' if this object is being disposed from a finalizer.

Called from within to create a new pass that visits every FunctionUnit in the module.

PassInfo object describing the pass. A phase list that will be executed once for each FunctionUnit in the program.

Called from within to create a new pass that visits every contract in the module.

A phase list that will be executed once for each contract FunctionUnit in the module.

Specifies the set of optional features supported by a particular code analysis host object.

The host supports no optional features.

The host supports function contracts. The host must override CodeAnalysisHost.CreateContractPass().

The host supports rules that modify the IR.

Base class for code analysis rules that validate contracts of functions.

Constructor for ContractRule.

ContractService object on which this rule depends.

Override this method to check a function precondition.

Control flow edge that would be executed if the contract assert evaluates to 'false'. List of contract assertions associated with the edge. Context in which the precondition is evaluated.

Override this method to check a function postcondition.

Control flow edge that would be executed if the contract assert evaluates to 'false'. List of contract assertions associated with the edge. Context in which the postcondition is evaluated.

Base class for all passes that execute tasks on FunctionUnits.

The type of unit the pass processes.

Constructor for ParallelPass.

The PassConfiguration for the new pass. PassInfo object describing the new pass. The task scheduler to use to schedule the tasks. The phase list to execute on each FunctionUnit.

Override this method to determine whether the FunctionUnit for the specified function is available for analysis.

The symbol of the function. 'true' if the function's FunctionUnit can be analyzed by this pass.

Graph used to determine the order that each pass visits the assembly's FunctionUnits. The program's CallGraph is not sufficient for this because it has no way of enforcing the correct ordering of uninstantiated generics without explicitly adding edges to create the appropriate dependency. This modification is done here rather that modifying the CallGraph.

Attribute class that marks a class as implementing a Phoenix-based FxCop rule.

Constructor for FxCopRuleAttribute.

A string uniquely identifying the rule. This should be a dotted name (e.g. "Microsoft.VisualStudio.CA1000"), similar to how .NET namespaces and classes are named. A string used as the name of the rule when displayed to the user. The category type that best classifies this rule.

Class providing metadata information about a Phoenix-based code analysis rule to be run over MSIL code.

Constructor for FxCopRuleInfo.

Discovery object used to load this rule's metadata. The attribute containing the metadata for the rule. The type that implements the rule.

Constructor for FxCopRuleInfo.

Discovery object used to load this rule's metadata. The attribute containing the metadata for the rule. The type that implements the rule.

The unique identifier of the analyzer that implements the rule.

Attribute class that marks a class as implementing a Phoenix-based FxCop rule.

Constructor for LocalizedFxCopRuleAttribute.

A string uniquely identifying the rule. This should be a dotted name (e.g. "Microsoft.VisualStudio.CA1000"), similar to how .NET namespaces and classes are named. The category type that best classifies this rule.

Attribute class that marks a class as implementing a Phoenix-based PREfast rule.

Constructor for LocalizedNativeRuleAttribute.

A string uniquely identifying the rule. This should be a dotted name (e.g. "Microsoft.VisualStudio.C6011"), similar to how .NET namespaces and classes are named. The category type that best classifies this rule.

Base class for implementing a Phoenix-base code analysis model.

Override this method to modify the IR of a function to provide additional information about its behavior.

FunctionUnit whose IR is to be modified.

Override this method to modify the IR of a contract function to provide additional preconditions and postconditions.

ContractInfo describing the contract function moduleUnit.

Override this method to add psi operators to the given block's successor nodes based on something that can be infered in the given block.

Block to analyze for inference opportunities. Returns a list of InferenceEdgeData objects representing the psi instructions that should be inserted or null.

Given a Psi instruction, retrive the inference pattern data of type T for that psi instruction.

Type of an inference pattern's data object. Psi instruction. Returns the requested inference pattern data object or null if it was not found.

Override this method to provide information about what memory locations may be modified or referenced by the specified function call.

The call instruction whose alias information is to be computed. A CallAliasInfo object specifying the memory locations referenced and modified by the function call. If the return value is null, this is equivalent to specifying the default values for all tag sets in the CallAliasInfo object.

Attribute class that marks a class as implementing a Phoenix-based code analysis model. The class to which it is applied must derive from .

Create a new ModelAttribute.

A string uniquely identifying the model. This should be a dotted name (e.g. "Microsoft.VisualStudio.SalModel"), similar to how .NET namespaces and classes are named.

A string uniquely identifying the model.

Provides metadata about a code analysis model.

Constructor for ModelInfo.

Discovery object that created this ModelInfo. Attribute instance containing the metadata for the model. The type that implements the model.

A string uniquely identifying the model.

Service that provides access to models for the behavior of functions.

Attribute class that marks a class as implementing a Phoenix-based PREfast rule.

Constructor for NativeRuleAttribute.

A string uniquely identifying the rule. This should be a dotted name (e.g. "Microsoft.VisualStudio.C6011"), similar to how .NET namespaces and classes are named. A string used as the name of the rule when displayed to the user. The category type that best classifies this rule.

Class providing metadata information about a Phoenix-based code analysis rule to be run over C/C++ code.

Constructor for NativeRuleInfo.

Discovery object used to load this rule's metadata. The attribute containing the metadata for the rule. The type that implements the rule.

Constructor for NativeRuleInfo.

Discovery object used to load this rule's metadata. The attribute containing the metadata for the rule. The type that implements the rule.

The unique identifier of the analyzer that implements the rule.

Base class for all passes that execute tasks in parallel.

The type of unit the pass processes. The type of target on which the pass runs tasks. This version of ParallelPass is used for the common case where the target key is the target itself.

Constructor for ParallelPass.

The PassConfiguration for the new pass. The order in which the pass visits the call graph. If the pass does not visit FunctionUnits, then this parameter should be CallGraphProcessOrder.None. The name of the new pass. PassInfo object describing the new pass. The task scheduler to use to schedule the tasks.

Base class for all passes that execute tasks in parallel.

The type of unit the pass processes. The type of target on which the pass runs tasks. The key type used to refer to discardable targets.

Constructor for ParallelPass.

Override this method to provide the list of keys for the targets on which to run the tasks.

The unit on which the pass is executing. A list of target keys identifying the targets on which the pass should run tasks. The returned list must be sorted such that the key for any given target appears in the list before the key for any target that depends on the first target.

Override this method to return the actual target for a specified target key.

The key of the target to be returned. The target to which the key refers. The ReleaseTarget method will be called on each target returned by the GetTarget method, to allow the pass to clean up or discard any resources allocated for the target.

Override this method to release resources for a target previously returned from GetTarget.

The target whose resources are to be released.

Override this method to execute tasks on the specified target.

The target on which to execute the tasks TargetContext describing the target.

Override this method to provide a custom hash code for a target key.

The target key whose hash code is to be returned. The hash code of the target key. The default implementation calls Object.GetHashCode on the target key.

Override this method to provide the list of targets which must be analyzed before the specified target.

The key of the target whose dependencies are to be computed. List to be populated with the keys of the targets on which depends.

This class stores information about pass order.

This class is immutable. Code which uses this class expects that it is immutable.

Base class for implementing a Phoenix-based code analysis rule.

Get the DiagnosticInfo object representing the warning implemented by this rule object.

The DiagnosticInfo object representing the warning implemented by this rule object. If this rule object implements more than one rule, this method will fail. To get a DiagnosticInfo object for a specific rule implemented by this rule object, use .

Get the DiagnosticInfo object representing a warning implemented by this rule object.

Unique identifier of the rule whose DiagnosticInfo is to be retrieved. This is the same string specified as the value of the RuleId property on the BaseRuleAttribute. The DiagnosticInfo object representing the specified warning implemented by this rule object.

Report a localized warning on a specific instruction.

Instruction containing the defect. Format arguments to substitute into the format string.

Report a localized warning on a specific symbol.

Symbol containing the defect. Format arguments to substitute into the format string.

Report a localized warning.

SourceContext of the location of the defect. Format arguments to substitute into the format string.

Report a localized warning.

Instruction containing the defect. Object that provides extra information about this violation. Format arguments to substitute into the format string.

Report a localized warning.

Symbol containing the defect. Object that provides extra information about this violation. Format arguments to substitute into the format string.

Report a localized warning.

SourceContext of the location of the defect. Object that provides extra information about this violation. Format arguments to substitute into the format string.

Report a warning on a specific instruction.

Instruction containing the defect. Format string for the description of the defect. Format arguments to substitute into the resolution description format string.

Report a warning on a specific symbol.

Symbol containing the defect. Format string for the description of the defect. Format arguments to substitute into the resolution description format string.

Report a warning.

SourceContext of the location of the defect. Format string for the description of the defect. Format arguments to substitute into the resolution description format string.

Report a warning on a specific instruction.

Instruction containing the defect. Format string for the description of the defect. Format arguments to substitute into the resolution description format string.

Report a warning on a specific symbol.

Symbol containing the defect. Format string for the description of the defect. Format arguments to substitute into the resolution description format string.

Report a warning.

SourceContext of the location of the defect. Format string for the description of the defect. Format arguments to substitute into the resolution description format string.

Frees any resources owned by this rule.

'true' if this object is being disposed as a result of a call to . 'false' if this object is being disposed from a finalizer.

Class providing metadata information about a Phoenix-based code analysis rule.

Constructor for PhoenixRuleInfo.

Discovery object used to load this rule's metadata. The attribute containing the metadata for the rule. The type that implements the rule.

Constructor for PhoenixRuleInfo.

Discovery object used to load this rule's metadata. The attribute containing the metadata for the rule. The type that implements the rule.

Gets the localized format string for the specified resolution.

The identifier of the resolution. This must be one of the identifiers in the list returned by the ResolutionIds property. The localized format string for the specified resolution.

This enum differentiates if a given rule needs IR modified after dataflow analysis operations (like rename-optimizations, Ir with PSI node etc.)

Dataflow type rules will be executed after IR is modified due to dataflow analysis operations (like rename-optimizations, Ir with PSI node etc.)

Lexical type rules will be executed before IR is modified due to dataflow analysis operations (like rename-optimizations, Ir with PSI node etc.)

Object that provides extra information about a violation.

ResolutionId of the resolution to be emitted. This may be null if the specified rule only implements one resolution.

RuleId of the rule reporting the defect. This may be null if this object only implements one rule.

Unique identifier used to differenciate between violations from the same rule on the same code element.

Indicates the kind of fix required to fix this violation.

Indicates the severity of the violation.

Will append a ": Lines:" string followed by a comma separated list of the lines you specified to the end of your resolution and will cause VS to highlight those lines when this violation is selected from the error list.

Returns the 'Lines:' string that should be appended to the end of a violation.

Rule manager base class decides if rules are applicable for the given module and manages any global state for the analysis

Add rule to the manager on loading rules before any engine runs

Runs before each engine analysis run

Runs for the current target module when it is loaded before analysis

Current target module

Gets all the rules applicable to the current module

Collection of all the rules applicable to the current module

Attribute class that marks a class as implementing a Phoenix-based rule manager. The class to which it is applied must derive from .

Create a new RuleManagerAttribute.

Provides metadata about a rule manager.

Constructor for RuleManagerInfo.

Discovery object that created this RuleManagerInfo. Attribute instance containing the metadata for the rule manager. The type that implements the rule manager.

Service that allows components to track statistics.

This class stores information about target state.

This class is immutable. Code which uses this class expects that it is immutable.

Base class for all passes that execute tasks.

The type of unit the pass processes.

Constructor for TaskPass.

PassInfo object describing the pass.

Override this method to determine if the pass should execute on the specified unit.

The unit on which to execute. 'true' if the pass should execute on the specified unit. The default implementation of this method always returns 'true'.

Override this method to implement the actual work to be done by the task.

The unit on which to execute. The PassContext describing the pass to be executed.

Attribute class that marks a class as implementing a Phoenix-based FxCop rule.

Constructor for UtilityExtensionInfo.

Discovery object used to load this utility's metadata. The attribute containing the metadata for the utility. The type that implements the utility.

ResolutionId of the resolution to be emitted. This may be null if the specified rule only implements one resolution.

Unique identifier used to differentiate between violations from the same rule on the same code element.

Indicates the kind of fix required to fix this violation.

Indicates the severity of the violation.

Returns the 'Lines:' string that should be appended to the end of a violation.

Supports inferences on compares of atleast one local variable.

Looks for two s connected together by an "And" or an "Or".

An that is able to make inferences based off of a code pattern that starts with an arbitrary . This allows other s to extend the code pattern that they are able to infer from by combining the pattern they know how to process with the patterns from s.

Gets the for for the code pattern that starts with

The that contains successor edges that this pattern may be able to infer new information on. The that is used to start looking for the code pattern that this recognizes. The for all , successor pairs that we can infer new information on.

Collection of static helper methods useful for matching inference patterns and other inference related tasks.

Given a basic block, looks for a branch instruction at the end and returns its the instruction that defines its predicate.

No need to return the branch condition code because for now we are always assuming the condition code for conditional branches is True.

Given a basic block, looks for a branch instruction at the end and returns its predicate.

No need to return the branch condition code because for now we are always assuming the condition code for conditional branches is True.

Given an operand, trace back to the instruction that defines that operand.

Walks back through assignments and conversions.

Determines if the given convert operand is safe to walk through. Safe means that the true or false value of the branch predicate will not be affected by the conversion.

Default method for calculating which psi instructions should be inserted. Inserts a Psi instruction for each given source operand on each successor (outgoing) edge from the given block.

Block where the inference has occured, its outgoing edges will be decorated with Psi instructions. Operands to insert Psi instructions for. Only use this method if it is safe to infer something about each operand on each possible outgoing edge.

Default method for calculating which psi instructions should be inserted on a specific edge. Inserts a Psi instruction for each given source operand on the successor (outgoing) edge with the given LabelOperandKind.

Block where the inference has occured, one of its outgoing edges will be decorated with Psi instructions. Indicates which successor (outgoing) edge the psi instruction(s) should be added to. Operands to insert Psi instructions for.

Insert Psi instructions on the fall-through edge for the this pointer after all callvirt instructions. On the fall-through edge, the this pointer is guaranteed to be non-null since the EH edge will be taken if the object was null.

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

Returns the cached ResourceManager instance used by this class.

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

Represents a base class subobject within an AggregateType.

The SelfInheritanceObject that contains this inheritance object.

For example, for the inheritance object representing the System.Object base class of System.String, the ContainingInheritanceObject would be the SelfInheritanceObject for System.String.

List of all base classes of this base class, both direct and indirect, plus this base class.

The base classes are returned in depth-first post-order. Virtual base classes only appear once, in the first position in which they would appear.

Gets the information about how the specified introducing virtual function is overridden in this inheritance object.

Symbol of the introducing virtual function whose override information is to be retrieved. An object containing the override information for the specified function. The function specified by must be introduced by the type of this inheritance object.

The BaseClass in the uninstantiated generic type that corresponds to this base class in an instantiated generic type, or if this base class is not contained in an instantiated type.

For example, the value of this property for IList<System.Object> in List<System.Object> would be IList<T> in List<T>.

Override the specified function in this inheritance object.

The introducing virtual function to be overridden. This function must be introduced by the type of this InheritanceObject. The function that provides the implementation with which to override. The inheritance object on which the overriding function will be called. The type of this InheritanceObject must be the same as the enclosing type of the overriding function. Flags specifying additional information about the override.

Override the specified function in this inheritance object.

The introducing virtual function to be overridden. This function must be introduced by the type of this InheritanceObject. The function that provides the implementation with which to override. Flags specifying additional information about the override. The enclosing type of the overriding function must appear exactly once in the inheritance hierarchy of the containing type.

Finds the InheritanceObject in a base class that corresponds to this inheritance object.

A BaseClass object representing the base class to translate to, contained in the containing type of this base class. The InheritanceObject contained in the type of that corresponds to this base class. In hierarchies that do not contain multiple non-virtual inheritance, this method is equivalent to calling on the base type. For example, if you had the BaseClass object for System.Object contained in System.IO.FileStream, and you wanted to find the corresponding base class for System.Object in System.IO.Stream, you would pass the BaseClass object for System.IO.Stream contained in System.IO.FileStream as the parameter.

Represents a base class subobject within an AggregateType.

Returns a string that represents the InheritanceObject.

A string description of this InheritanceObject.

The type of the inheritance object.

For example, for the inheritance object representing the System.Object base class of System.String, the Type property would be the type for System.Object.

The SelfInheritanceObject that contains this inheritance object.

For example, for the inheritance object representing the System.Object base class of System.String, the ContainingInheritanceObject would be the SelfInheritanceObject for System.String.

The type of the class containing this inheritance object.

For example, for the inheritance object representing the System.Object base class of System.String, the ContainingType property would be the type for System.String.

List of immediate base classes of this inheritance object.

List of virtual functions introduced by this inheritance object.

The InheritanceObject in the uninstantiated generic type that corresponds to this inheritance object in an instantiated generic type, or if this inheritance object is not contained in an instantiated type.

For example, the value of this property for IList<System.Object> in List<System.Object> would be IList<T> in List<T>.

List of all base classes of this inheritance object, both direct and indirect.

The base classes are returned in depth-first post-order. Virtual base classes only appear once, in the first position in which they would appear.

List of all base classes of this inheritance object, both direct and indirect, plus this inheritance object.

The inheritance objects are returned in depth-first post-order. Virtual base classes only appear once, in the first position in which they would appear.

The inheritance object for the primary base class of this inheritance object, if any.

The chain of primary base classes of this inheritance object, starting with this object's immediate primary base, and continuing in order to the top-level primary class.

Gets the information about how the specified introducing virtual function is overridden in this inheritance object.

Gets an array of all inheritance objects, including direct and indirect base classes as well as this inheritance object itself, that have the specified type.

The type of the inheritance objects to find. An array of the InheritanceObject objects of the specified type. The array will be empty if there are no inheritance objects of the specified type.

Gets an array of all base classes (direct and indirect) of this inheritance object that have the specified type.

The type of the base classes to find. An array of the BaseClass objects of the specified type. The array will be empty if there are no base classes of the specified type.

Finds an immediate base class of this object by type.

The type of the base class to find. The immediate base class whose type matches the specified type, or if no such base class exists.

Finds the single base class, direct or indirect, with the specified type.

The type of the base class to find. The base class with the specified type, or if there is not exactly one base class of the specified type.

Finds the single inheritance object, including direct and indirect base classes as well as this inheritance object itself, with the specified type.

The type of the inheritance object to find. The inheritance object with the specified type, or if there is not exactly one inheritance object of the specified type.

Gets the InheritanceObject in the instantiation of a generic type that corresponds to this inheritance object in the uninstantiated generic type.

Instantiated generic type in which to find the object. The InheritanceObject contained in that corresponds to this InheritanceObject. For example, calling this method on the BaseClass for IList<T> in List<T>, passing List<System.Object> as , would return IList<System.Object> in List<System.Object>.

Finds the BaseClass object in a derived class that corresponds to this inheritance object.

A BaseClass object representing this inheritance object's containing type, contained in the destination type. The BaseClass object in the containing type of that corresponds to this inheritance object. In hierarchies that do not contain multiple non-virtual inheritance, this method is equivalent to calling on the derived type. For example, if you had the BaseClass object for System.Object contained in System.IO.Stream, and you wanted to find the corresponding base class for System.Object in System.IO.FileStream, you would pass the BaseClass object for System.IO.Stream contained in System.IO.FileStream as the parameter.

Gets the entire vtable for the inheritance object. Contains all of the virtual methods inherited and introduced by this inheritance object.

This method only applies to managed code because it is keyed by FunctionSymbol and in managed code all inheritance is virtual inheritance.

Dumps the entire vtable for the inheritance object. Dumps out all of the virtual methods inherited and introduced by this inheritance object and what their current implementation is.

For debugging only. This method only applies to managed code because it is keyed by FunctionSymbol and in managed code all inheritance is virtual inheritance.

An InheritanceObject representing a non-virtual base class.

The InheritanceObject for the type immediately derived from this base class.

Flags describing additional information about an override.

No override flags set.

This override occurred explicitly (via a MethodImpl) rather than by matching name and signature.

This override is the primary virtual function slot for the overriding function.

An InheritanceObject representing the complete object of a type, rather than a base class sub-object.

The SelfInheritanceObject that contains this inheritance object.

For example, for the inheritance object representing the System.Object base class of System.String, the ContainingInheritanceObject would be the SelfInheritanceObject for System.String.

Gets the information about how the specified introducing virtual function is overridden in this inheritance object.

The SelfInheritanceObject in the uninstantiated generic type that corresponds to this inheritance object in an instantiated generic type, or if this inheritance object is not contained in an instantiated type.

For example, the value of this property for List<System.Object> in List<System.Object> would be List<T> in List<T>.

An InheritanceObject representing a virtual base class.

Information about how an introducing virtual function is overridden.

The function that provides the overriding implementation of the introducing function.

The inheritance object on which the overriding function will be called.

Flags describing additional information about an override.

Returns a string that represents the OverrideInfo.

A string description of this OverrideInfo.

Uniquely identifies an introducing virtual function in an inheritance hierarchy.

Constructor for IntroducingFunctionReference.

The introducing virtual function. The InheritanceObject that introduces the function.

The introducing virtual function.

The InheritanceObject that introduces the function.

Information about how this introducing virtual function is overridden.

Returns a string that represents the IntroducingFunctionReference.

A string description of this IntroducingFunctionReference.

Helper methods for the Phx.Types.AggregateType type.

Finds the single base class, direct or indirect, with the specified type.

The type on which to find the base class. The type of the base class to find. The base class with the specified type, or if there is not exactly one base class of the specified type.

Finds the single inheritance object, including direct and indirect base classes as well as this inheritance object itself, with the specified type.

The type on which to find the inheritance object. The type of the inheritance object to find. The inheritance object with the specified type, or if there is not exactly one inheritance object of the specified type.

Gets the SelfInheritanceObject for the specified type.

The type whose SelfInheritanceObject is to be retrieved. The SelfInheritanceObject for the specified type.

Gets the list of virtual functions introduced by the specified type.

The type whose list of introducing functions is to be retrieved. The list of virtual functions introduced by the specified type, or if the type does not introduce any virtual functions.

Gets the list of introducing functions that are overridden by the specified function.

The type in which the functions are overridden. The overriding function. An array of IntroducingFunctionReference objects containing all of the introducing functions that overrides in .

Gets the entire vtable for a managed type. Contains all of the virtual methods inherited and introduced by this AggregateType.

This method only applies to managed code because it is keyed by FunctionSymbol and in managed code all inheritance is virtual inheritance.

Gets a collection of all of the base class implementations and definitions of this method.

Gets the information about how the specified introducing virtual function is overridden in this type.

Type for which the override information is to be retrieved. Symbol of the virtual function whose override information is to be retrieved. An object containing the override information for the specified function. The returned OverrideInfo object specifies the function that overrides the specified function's primary introducing slot. The specified function's primary introducing slot must be introduced either by the specified type, or by a unique base class of the specified type.

Returns the name of the Namespace that contains the AggregateType.

Return true if the specified aggregate type is marked as compiler generated.

The aggregate type to test. 'true' if is compiler generated.

Returns true if the given aggregate type is derived from the given type reference.

Returns true if the given aggregate type is assignable to the given type reference. Returns false otherwise.

Returns true if the given aggregate type is derived from the given type reference.

Returns true if the given aggregate type is assignable to the given type reference. Returns false otherwise.

Determine if the specified type is visible outside the assembly that contains it.

The type to test. 'true' if the type can be referenced from another assembly, 'false' otherwise. This method returns 'false' for any type that is only visible to a friend assembly.

Represents a method signature where all the (unknown number of) arguments have the same type.

Creates an AllParametersSameMethodSignatureReference with the given parameter type.

The type of all parameters of the method.

Checks if a particular function type matches this signature.

The function type to check. 'true' if and only if all parameters of the give function type match the signature type.

Represents a CLR method signature that will match any signature.

Use this type if you want to match all the overloads of a given method.

Determine if this method signature reference refers to the specified Phoenix function type.

Phoenix FunctionType to compare to this method signature reference. 'true' if this method signature reference refers to the specified FunctionType.

String representation of the MethodSignatureReference.

This is used for debugging only.

A reference to any type.

Gets a reference to the AnyTypeReference instance.

Determine if this type reference refers to the specified Phoenix type

Phoenix type to compare to this type reference. Always returns true.

String representation of the TypeReference.

This is used for debugging only.

Provides information about an argument to a function call.

Constructor for ArgumentInfo.

The operand containing the value of the argument. The Parameter to which the argument is being passed. The ParameterSymbol of the parameter to which the argument is being passed. This may be null.

Constructor for ArgumentInfo.

The operand containing the value of the argument. The Parameter to which the argument is being passed. The ParameterSymbol of the parameter to which the argument is being passed. This may be null. Additional information about the argument.

Constructor for ArgumentInfo.

An ArgumentWithParameter describing the argument.

The operand containing the value of the argument.

The Parameter to which the argument is being passed.

The ParameterSymbol of the parameter to which the argument is being passed. This may be null.

Tests whether the argument is passed to an 'out' parameter.

Tests whether the argument is passed to a 'ref' parameter.

Specifies additional information about an argument to a function call.

No additional information.

The argument is passed to an 'out' parameter.

The argument is passed to a 'ref' parameter.

The argument is passed by name.

A reference to a CLR array type.

Create a new ArrayTypeReference.

The element type of the array.

Determine if this type reference refers to the specified Phoenix type

Phoenix type to compare to this type reference. 'true' if this type reference refers to the specified type.

String representation of the TypeReference.

This is used for debugging only.

Class for reading arguments from the blob of a custom attribute.

Constructor for AttributeArgumentParser.

The attribute whose blob is to be parsed.

Extension methods for use with Phoenix attribute symbols.

Gets the values of the unnamed arguments of the attribute.

Type of the first unnamed argument. The attribute whose arguments are to be read. The value of the first unnamed argument.

Gets the values of the unnamed arguments of the attribute.

Type of the first unnamed argument. Type of the second unnamed argument. The attribute whose arguments are to be read. The value of the first unnamed argument. The value of the second unnamed argument.

Gets the values of the unnamed arguments of the attribute.

Type of the first unnamed argument. Type of the second unnamed argument. Type of the third unnamed argument. The attribute whose arguments are to be read. The value of the first unnamed argument. The value of the second unnamed argument. The value of the third unnamed argument.

Gets the value of the specified named attribute argument.

This method assumes the specified named argument is a property. Type of the named argument. The attribute whose arguments are to be read. Name of the named argument. (Must be the name of a readable property on the attribute). value of the named argument. Returns false if the specified named argument was not specified on the attribute instance. Otherwise returns true.

Gets the value of the specified named attribute argument.

Type of the named argument. The attribute whose arguments are to be read. Name of the named argument. (Must be the name of a readable property or field on the attribute). True if the specified name is the name of a property, false if it is the name of a field. value of the named argument. Returns false if the specified named argument was not specified on the attribute instance. Otherwise returns true.

Extension methods for use with Phoenix basic block.

Extension methods for use with CallInstructions

Determines the function that would be called if the dynamic type of the instruction's 'this' pointer operand were the same as its static type.

The call instruction. The function that would be called by this instruction based on the static type of the 'this' pointer operand. For example:


            class A
            {
                public virtual void Foo() { }
            }
            class B : A
            {
                public override void Foo() { }
            }
            class C : B
            {
                public override void Foo() { }
            }

Given a call instruction whose FunctionSymbol property is A.Foo, and whose 'this' pointer argument is of type B, ResolveOverrideForStaticType would return the FunctionSymbol for B.Foo, even if the dynamic type of the 'this' pointer operand is C.

Gets the that represents the resources that points to.

The that takes as an argument. The whose is desired. must have its IsAddress property set to true. The that represents the resources that points to.

Gets the for the argument .

The that takes as an argument. The whose is desired. must be an argument to .

Specifies the kind of method being called in an expression.

A normal method call.

A call to the getter or setter of a non-indexed property.

A call to the getter or setter of an indexed property.

An expression formatter for rendering Phoenix expressions as C++ source code.

Gets the display name for the specified

The keyword to get the display name for. The display name of

Gets the display name for the specified

The Phoenix object to get the display name for. 's display name.

Gets the string to use for prefixing an array. "[" in C#.

Gets the string to use for suffixing an array. "]" in C#.

Gets the string to use to represent a bitwise OR operation. "|" in C#.

Gets the string to use for seperating the namespace name from the class name, or the class name from a static method name. "::" in C++.

Gets the string to use for seperating the class name from an instance method name when accessed through a pointer. "->" in C#.

Gets the string to use for seperating the class name from an instance method name when accessed through a reference. "." in C#.

Gets the string to use for declaring a managed pointer. "^" in C++.

Gets the string to use to represent a string concatenation operation. "+" in C#.

Primary constructor for a CPlusPlusExpressionFormatter.

SharedParamArrayAnalysis to use for extracting individual arguments from a parameters array.

Formats an integer immediate.

The value to format. The type of the literal. An IFormatProvider to use when formatting. The string representation of the integer.

Format the default value of a value type.

The value type to format. An IFormatProvider to use when formatting. A string representation of the default value of the value type.

Format the default value of a type variable type.

The type variable type to format. An IFormatProvider to use when formatting. A string representation of the default value of the type variable type.

Formats an isinst instruction as a use of the dynamic_cast operator.

The isinst instruction to format. An IFormatProvider to use when formatting. "dynamic_cast<[type]>([var])" where [var] is the variable be cast, and [type] is the destination type

Formats a method call.

The call to format. The type that the destination of had when it it was used. The type that results in. An IFormatProvider to use in formatting the expression. The formatted method call.

Helper methods for Dispose related analysis.

Returns true if the given type typically has its dispose ownership transfered when passed to a dispose creation call.

Given a call instruction that takes a disposable operand, returns that disposable operand if the destination operand of this instruction takes ownership of disposing that disposable source operand.

Currently relies on the heuristic that almost all disposable creation calls that take a stream end up taking ownership of disposing that stream.

Given a call instruction that takes a disposable operand, returns that disposable operand if the destination operand of this instruction takes ownership of disposing that disposable source operand.

Currently relies on the heuristic that almost all disposable creation calls that take a stream end up taking ownership of disposing that stream.

Returns true if the given type is derived from System.IDisposable, or is an object pointer to a disposable type.

Returns true if the instruction is creating a disposable type instance

This function returns false for disposable creation calls that take ownership of another disposable object.

Returns true if the instruction is creating a disposable type instance

Returns true if the given is a call to a dispose method.

Returns true if the given is a dispose method.

Type reference for System.IDisposable

Type reference for any type derived from System.IDisposable

Method reference for System.IDisposable.Dispose()

Method reference for *.Dispose(bool)

Method reference for a method named "Close" a type derived from System.IDisposable

Describes different kinds of Dispose-like methods.

Not a dispose-like method.

An override of System.IDisposable.Dispose.

A virtual method named Dispose that takes a single Boolean parameter, as is used when implementing the standard Dispose pattern.

A method named Close on a type that implements System.IDisposable.

A reference to any instantiation of a specified generic CLR type.

Constructor for InstantiatedTypeReference.

The generic type. The generic argument types. The InstantiatedTypeReference object will match any type that is an instantiation of with argument types that match the types specified in .

Constructor for InstantiatedTypeReference.

The generic type. The generic argument types. The InstantiatedTypeReference object will match any type that is an instantiation of with argument types that match the types specified in .

Determine if the specified Phoenix type refers to or derives from this type reference.

Phoenix type to compare evaluate. 'true' if the specified type refers to or derives from this type reference.

String representation of the TypeReference.

This is used for debugging only.

Get the that is written in.

The whose is needed. The that is written in.

Represents a reference to any CLR method that overrides a specified method.

Constructor for OverrideMethodReference.

A MethodReference to the introducing method whose overrides are to be matched. 'true' if the new OverrideMethodReference should match the introducing method itself, 'false' if it should match only strict overrides of the introducing method.

Constructor for OverrideMethodReference.

A MethodReference to the introducing method whose overrides are to be matched. The new OverrideMethodReference will match any method that overrides the specified introducing method, including the introducing method itself.

Determine if this method reference refers to the specified Phoenix method.

Phoenix FunctionSymbol to compare to this method reference. 'true' if this method reference refers to the specified FunctionSymbol.

Tuple struct as proposed in ECMA TR-089

Base class for all expression formatters.

Formats a Phoenix expression for display to the user.

The that holds a string to format. An IFormatProvider to use when formatting the expression. The formatted version of string that holds.

Formats a Phoenix expression for display to the user.

The Operand that represents the expression to be formatted. An IFormatProvider to use when formatting the expression. The formatted expression.

Shared copy analysis object for use by this expression formatter.

Shared param array analysis object for use by this expression formatter.

Formats a Phoenix expression for display to the user.

The Operand that represents the expression to be formatted. The type had when it it was used. The original type that was defined with. An IFormatProvider to use when formatting the expression. The formatted expression.

Formats the Phoenix expression defined by 's definition instruction.

The operand whose definition instruction should be formatted. The type had when it it was used. The original type that was defined with. An IFormatProvider to use when formatting the expression. The formatted expression.

Formats a VariableOperand.

The operand to format. The type had when it it was used. The original type that was defined with. An IFormatProvider to use in formatting the expression. The name of the variable as a string.

Formats a that holds the address to a different .

The to format. IsAddress must be true on . The type had when it it was used. The original type that was defined with. An IFormatProvider to use in formatting the expression. The formatted string of the operand that contains the address of.

Formats a MemoryOperand.

The memory operand to format. The type had when it it was used. The original type that was defined with. An IFormatProvider to use in formatting the expression. The MemoryOperand formatted as a field, array, or pointer access.

Formats a .

The to format. The type had when it it was used. The original type that was defined with. An IFormatProvider to use in formatting the expression. The formatted string representation of .

Formats a method call.

The call to format. The type that the destination of had when it it was used. The type that results in. An IFormatProvider to use in formatting the expression. The formatted method call.

Formats the argument list to a method call.

The kind of method call. The arguments to the call. An IFormatProvider to use in formatting the expression. The formatted argument list.

Formats the argument list to a method call.

The instruction containing the method call. An IFormatProvider to use in formatting the expression. The formatted argument list.

Formats a single argument of a .

The containing the and information to format. An IFormatProvider to use in formatting the expression. The formatted argument.

Formats the contents of an array if they are known. This function is called to format params arrays.

The array whose contents will be formatted. The string to insert between each array element. An to use in formatting the expression. The formatted argument.

Formats a call to String.Concat.

The instruction containing the call to String.Concat. The type that the destination of had when it it was used. The type that results in. An IFormatProvider to use in formatting the expression. The formatted call to String.Concat

Formats a call to String.Concat(string[]).

The instruction containing the call to String.Concat(string[]). The type that the destination of had when it it was used. The type that results in. An IFormatProvider to use in formatting the expression. The formatted call to String.Concat(string[]).

Formats a call to System.Array.Get.

The instruction that contains the call to System.Array.Get The type that the destination of had when it it was used. The resulting element type of the array. An IFormatProvider to use in formatting the expression. The formatted call to System.Array.Get.

Formats the portion of a static function call that exists before the function name. For example, in a call to "String.Format", FormatStaticPrefix is responsible for outputting "String."

The instruction that contains the method call to format. The type had when it it was used. An IFormatProvider to use in formatting the expression. The prefix to the static function call in .

Formats the portion of an instance function call that exists before the function name. For example, in a call to "myString.Format", FormatInstancePrefix is responsible for printing out "myString."

The instruction that contains the method call to format. The type that the destination of had when it it was used. An IFormatProvider to use in formatting the expression. The prefix to the static function call in .

Formats a newobj instruction.

The newobj instruction to format. The type that the destination of had when it it was used. The original type that was defined with. An IFormatProvider to use in formatting the expression. The string represenation of the newobj instruction.

Returns true if this is the function symbol for a System.Delegate.Invoke method.

Formats a call to System.Delegate.Invoke

The instruction that contains the call to System.Delegate.Invoke The type that the destination of had when it it was used. The resulting element type of the call. An IFormatProvider to use in formatting the expression. The formatted call to System.Delegate.Invoke.

Formats an isinst instruction.

The isinst instruction to format. The type that the variable argument to IsInst had when it it was used. The original type that the variable argument to IsInst was defined with. An IFormatProvider to use in formatting the instruction. The string representation of the isinst instruction.

Formats a cast from one type to another as a C-style cast.

The variable that is being cast. The type the variable is being cast to. The type that the variable argument to the cast had when it it was used. The original type that that the variable argument to the cast was defined with. An IFormatProvider to use in formatting the instruction. "([type])[var]" where [type] is the destination type, and [var] is the variable being cast.

Formats a conversion from one type to another.

The instruction that contains the convert operation. The type that the variable argument to the conversion had when it it was used. The original type that that the variable argument to the conversion was defined with. An IFormatProvider to use in formatting the instruction. The formatted type conversion.

Formats an immediate operand.

The operand for format for output. The type had when it was used. The original type that was defined with. An IFormatProvider to use in formatting the expression. The formatted immediate.

Formats the default value of the specified type.

Type whose default value is to be formatted. An IFormatProvider to use in formatting the expression. The formatted default value expression.

Formats an integer literal.

The value to format. The type of the literal. An IFormatProvider to use when formatting. The string representation of the integer.

Formats a floating point literal.

The value to format. The type of the literal. An IFormatProvider to use when formatting. The string representation of the float.

Formats a Boolean literal.

The value to format. An IFormatProvider to use when formatting. The string representation of the Boolean.

Formats a character literal.

The value to format. An IFormatProvider to use when formatting. The string represenation of the character.

Formats a character literal.

The character to format The IFormatProvider to use when formatting. The escaped string representation of the character.

Formats a string immediate.

The immediate to format. An IFormatProvider to use when formatting. The string representation of the string.

Formats a string literal.

The literal to format. An IFormatProvider to use when formatting. The escaped and formatted version of .

Format the default value of a value type.

The value type to format. An IFormatProvider to use when formatting. A string representation of the default value of the value type.

Format the default value of a type variable type.

The type variable type to format. An IFormatProvider to use when formatting. A string representation of the default value of the type variable type.

Formats an add .

The containing the addition expression. The type the destination of the add instruction had when it it was used. The resulting type of this expression. An IFormatProvider to use in formatting the expression. The formatted add .

Formats a pointer addition .

The pointer argument to the add instruction. The non-pointer argument to the add instruction. The type the destination of the add instruction had when it it was used. The resulting type of this expression. An to use in formatting the expression. The formatted pointer addition .

Formats a unary expression.

The source operand of the expression. The type the result of the expression had when it was used. The resulting type of this expression. The string representation of the formatted instruction. An to use in formatting the expression. The formatted expression.

Formats an instruction that takes one argument and produces one explicit result.

The to format. The type the destination of the instruction had when it was used. The resulting type of this expression. An to use in formatting the expression. The string representation of the formatted instruction.

Formats a binary expression.

The first source operand of the expression. The second source operand of the expression. The string representation of the formatted instruction. An to use in formatting the expression. The formatted expression.

Formats an instruction that has takes two arguments and results in one explicit result.

The to format. The resulting type of this expression. An to use in formatting the expression. The string representation of the formatted instruction.

Formats a LdLen instruction as an access to the Length property of an array.

Formats a NewArray instruction as an array constructor call.

Formats a NewObj instruction with a managed array type as an array constructor call.

The to format. The type of the array being created. An to use in formatting the expression.

Gets the display name for the specified

The keyword to get the display name for. The display name of

Gets the display name for the specified

The Phoenix object to get the display name for. 's display name.

Gets the string to use for prefixing an array. "[" in C#.

Gets the string to use for suffixing an array. "]" in C#.

Gets the string to use to represent a bitwise OR operation. "|" in C#.

Gets the string to use for seperating the namespace name from the class name, or the class name from a static method name. "::" in C++.

Gets the string to use for seperating the class name from an instance method name when accessed through a pointer. "->" in C#.

Gets the string to use for seperating the class name from an instance method name when accessed through a reference. "." in C#.

Gets the string to use for declaring a managed pointer. "^" in C++.

Gets the string to use to represent a string concatenation operation. "+" in C#.

An expression formatter for rendering Phoenix expressions as C# source code.

Gets the display name for the specified

The keyword to get the display name for. The display name of

Gets the display name for the specified

The Phoenix object to get the display name for. 's display name.

Gets the string to use for prefixing an array. "[" in C#.

Gets the string to use for suffixing an array. "]" in C#.

Gets the string to use to represent a bitwise OR operation. "|" in C#.

Gets the string to use for seperating the namespace name from the class name, or the class name from a static method name. "::" in C++.

Gets the string to use for seperating the class name from an instance method name when accessed through a pointer. "->" in C#.

Gets the string to use for seperating the class name from an instance method name when accessed through a reference. "." in C#.

Gets the string to use for declaring a managed pointer. "^" in C++.

Gets the string to use to represent a string concatenation operation. "+" in C#.

Formats a single argument of a .

The containing the and information to format. An IFormatProvider to use in formatting the expression. The formatted argument.

Primary constructor for a CSharpExpressionFormatter.

SharedParamArrayAnalysis to use for extracting individual arguments from a parameters array.

If the specified call instruction, is a dynamic operation, finds the call instruction that created the call site binder for the operation.

The call instruction of the possibly dynamic operation. The call instruction that created the call site binder for the operation, or null if the call does not appear to be a dynamic operation.

Formats a method call.

The call to format. The type that the destination of had when it it was used. The type that results in. An IFormatProvider to use in formatting the expression. The formatted method call.

Converts the integer value of a CSharpArgumentInfoFlags enum to an ArgumentInfoOptions enum.

The value of the CSharpArgumentInfoFlags enum. The converted ArgumentInfoOptions enum.

Resolves the constant value of an enum operand.

The operand whose value is to be resolved. The value of the operand, or null if the value cannot be resolved.

Resolves the value of an ExpressionType enum operand.

The operand whose value is to be resolved. The value of the operand, or null if the value cannot be resolved.

Get an ArgumentInfo object describing the argument to a dynamic operation.

The argument operand. The kind of parameter to which the argument is passed. List of operands containing CSharpArgumentInfo objects describing the arguments to the operation. The index of the argument. An ArgumentInfo object describing the argument.

Format a dynamic convert operation.

The call to Invoke on the delegate. Format provider to use when formatting the expression. The formatted expression, or null if the expression could not be formatted.

Format a dynamic binary operation.

The call to Invoke on the delegate. The call that created the call site binder. Format provider to use when formatting the expression. The formatted expression, or null if the expression could not be formatted.

Format a dynamic unary operation.

Format a dynamic member access operation.

Format a dynamic invoke operation.

Format a dynamic member invoke operation.

Format a dynamic indexer operation.

Get a list of ArgumentInfo objects describing the arguments to a dynamic operation.

The call to Invoke on the delegate. List of operands containing CSharpArgumentInfo objects describing the arguments to the operation. A list describing the arguments to the operation, or null if the arguments could not be computed.

Formats an isinst instruction as a use of the 'as' operator.

The isinst instruction to format. An IFormatProvider to use when formatting. "[var] as [type]" where [var] is the variable be cast, and [type] is the destination type

Format the default value of a value type.

The value type to format. An IFormatProvider to use when formatting. A string representation of the default value of the value type.

Format the default value of a type variable type.

The type variable type to format. An IFormatProvider to use when formatting. A string representation of the default value of the type variable type.

Represents a reference to a C++ method with a specified decorated name.

Constructor for DecoratedNamedMethodReference.

The decorated name of the method to be matched.

Determine if this method reference refers to the specified Phoenix method.

Phoenix FunctionSymbol to compare to this method reference. 'true' if this method reference refers to the specified FunctionSymbol.

String representation of the DecoratedNamedMethodReference.

A reference to a CLR type or any type derived from it.

Constructor for DerivedTypeReference.

The base type. Specifies whether this DerivedTypeReference should match the type specified by , or only types that are strictly derived from . The DerivedTypeReference object will match any type that is derived, directly or indirectly, from the . If is true, the reference will also match itself.

Constructor for DerivedTypeReference.

The base type. The DerivedTypeReference object will match any type that is derived, directly or indirectly, from the , as well as itself.

Determine if the specified Phoenix type refers to or derives from this type reference.

Phoenix type to compare evaluate. 'true' if the specified type refers to or derives from this type reference.

String representation of the TypeReference.

This is used for debugging only.

Class that converts Phoenix symbols to a resolution string formatted in the style of a given programming language.

Converts a Phoenix symbol (like a function or type) into a user readable resolution string formatted in the style of the given .

The Phoenix Symbol to convert to a string. Note that this is not typed to a Phoenix symbol because certain types that act as symbols do not actually derive from Symbol (like ParameterSymbol). Specifies the programming language style the string should be formatted in. User readable string formatted in the style of the given .

Returns a CSharp resolution display string or "Unknown" if errors occured while formatting the given Phoenix object.

Will not throw exceptions.

A service for accessing expression formatters by source language.

Constructor for the ExpressionFormatterService.

The purpose of this class is to provide utilities for dealing with expressions.

Unwraps the type if it is a pointer and gives you the actual type it was refering to.

The type to unwrap if nessessary. The underlying type that was being refered to.

Determines if the FunctionArgument is a params array parameter.

Determine if an operand would cause an exception if it had a value of null.

The operand to be queried. 'true' if executing the instruction containing the operand would result in an exception if the value of the operand were null.

Determines whether an operand is a buffer that could potentially be overrun.

the operand to check true if the operand is a pointer and is not an object pointer

Represents a reference to a field of a CLR type.

Determine if this field reference refers to the specified Phoenix field.

Phoenix FieldSymbol to compare to this field reference. 'true' if this field reference refers to the specified FieldSymbol.

Determine if this field reference refers to the specified Phoenix static field.

Phoenix StaticFieldSymbol to compare to this field reference. 'true' if this field reference refers to the specified StaticFieldSymbol.

Extension methods for use with Phoenix field symbols.

Return true if the specified field symbol is marked as compiler generated.

The field symbol to test. 'true' if is compiler generated.

Represents a single format item within a format string.

Convert the FormatItem to a human-readable string.

A string representation of the FormatItem.

The index of the format argument referenced by this format item (e.g. '3' for {3:hh}).

The kind of alignment specified by this format item (e.g. 'Left' for {3,-2}).

The minimum width specified by this format item (e.g. '2' for {3,-2}).

The custom format string specified by this format item (e.g. 'hh' for {3:hh}).

Alignment kind used by FormatItem.

The format item is not aligned.

The format item is left-aligned.

The format item is right-aligned.

The purpose of this class is to provide utilities for identifying and dealing with framework types.

Evaluates if the given Parameter is a System.String type.

Determines if the specified operand is a System.String.

The operand to test. 'true' if the specified operand is of the type System.String.

Determines if the specified operand is a System.Object.

The operand to test. 'true' if the specified operand is of the type System.Object.

This is a temporary solution for generating the full name for symbols until the NameProvider stuff can be ported.

Helper methods for the Phx.Symbols.FunctionSymbol type.

Gets a collection of all of the base class implementations and definitions of this method.

Gets the primary introducing virtual function of this FunctionSymbol.

The FunctionSymbol whose primary introducing function is to be retrieved. An object that identifies the primary introducing function. A virtual function may override multiple introducing functions. The primary introducing function is the function whose virtual function table slot will be used if a virtual call to this function is executed.

Is this function an introducing virtual function?

The function symbol to test. 'true' if the function is an introducing virtual function, 'false' otherwise.

Gets the function symbol on an instantiated type that corresponds to this function symbol.

The function symbol whose corresponding function is to be retrieved. The instantiated generic type on which to find the corresponding function. The function on that corresponds to the specified function. The parameter may be a function on an uninstantiated generic type, or on a type that is an instantiation of the same generic type from which was instantiated.

Takes a get or set FunctionSymbol and returns its coresponding PropertySymbol.

It is theoretically possible for more than one property to point to the same get or set method. This method just returns the first matching PropertySymbol it finds. A get or set FunctionSymbol. Returns null if no coresponding PropertySymbol is found.

Determines if the FunctionSymbol is the getter method of a property.

The FunctionSymbol to test. 'true' if is the getter associated with a property.

Determines if the FunctionSymbol is the setter method of a property.

The FunctionSymbol to test. 'true' if is the setter associated with a property.

Takes a get or set FunctionSymbol and returns its coresponding EventSymbol.

It is theoretically possible for more than one Event to point to the same accessor method. This method just returns the first matching EventSymbol it finds. An event accessor (add/remove/fire) FunctionSymbol. Returns null if no coresponding EventSymbol is found.

Determines if the specific function can be called from outside of the assembly that declares it.

The function to be tested. 'true' if the function can be called from outside the assembly that declares it. Any function that is visible outside of its assembly can be called from outside the assembly. In addition, a function can be called from outside its assembly if it overrides a function that is either visible outside the assembly, or is declared in a different assembly.

Returns a value indicating whether the specified is an anonymous method.

The of the method to check. if is an anonymous method, otherwise, .

Returns the of the specified anonymous method's declaring method.

The anonymous method whose declaring method is needed. The for the method that declares or if is not an anonymous method.

Returns the anonymous method s that are declared in .

The of method whose anonymous methods will be returned. A containing the anonymous methods s of or an empty list if does not have any anonymous methods.

Return true if the specified function symbol is marked as compiler generated.

The function symbol to test. 'true' if is compiler generated.

Represents a reference to the generic argument list a CLR method or type.

Determine if this generic argument list reference refers to the specified Phoenix generic argument list.

Phoenix TypeList to compare to this generic argument list reference. 'true' if this generic argument list reference refers to the specified argument list.

A GenericArgumentListReference that matches an empty generic argument list.

Interface implemented by any object that refers to an entity in source code.

The SourceContext with the location of the object in source code.

Interface to be implemented by any class that will be used to render Phoenix expressions to the user.

Format an expression into a human-readable string resembling source code.

The root of the expression tree to format. Provides additional preferences for formatting. The formatted expression.

Excapes and formats a literal string as it would be in source code.

The containing the string to format. Provides additional preferences for formatting. The formatted string literal.

Class that provides a way for an IExpressionFormatter to format arbitrary string literals.

Create a new .

The literal to format.

Provides readonly access to the contained literal .

Represents a reference to a method of a CLR type.

Determine if this method reference refers to the specified Phoenix method.

Phoenix FunctionSymbol to compare to this method reference. 'true' if this method reference refers to the specified FunctionSymbol.

Dictionary that maps from FunctionSymbol to a user-specified value. The dictionary is populated using MethodReference objects as the keys, but lookup is done using FunctionSymbols as the keys.

Create a new MethodReferenceDictionary.

The default value for any method not in the dictionary is assumed to be default(TValue).

Create a new MethodReferenceDictionary.

The default value to be returned when looking up a method that is not in the dictionary.

Add a mapping from a MethodReference to a user-specified value.

Reference to the method to use as a key. User-specified value to map the method to.

Gets the value associated with a specified method.

FunctionSymbol of the method for which the value is to be retrieved. The value associated with the specified method. If the method is not found, the return value is the default value specified in the constructor. If more than one key matches this function symbol, one of the matching values will be returned, but it is undefined which one is actually returned.

Represents a reference to the signature of a CLR method.

Determine if this method signature reference refers to the specified Phoenix function type.

Phoenix FunctionType to compare to this method signature reference. 'true' if this method signature reference refers to the specified FunctionType.

A MethodSignatureReference that matches any signature.

Extension methods for use with Phoenix module units.

Gets the language that the module moduleUnit is written in.

The module moduleUnit whose language is desired. The SourceLanguage that the module moduleUnit is written in. If pdbs are missing, the source language will be computed using the contents of the module. In some cases the result of the computation may be incorrect.

Represents a reference to a CLR field with a specified name.

Creates a new NamedFieldReference object.

The enclosing type of the field. The name of the field. 'true' if the field is a staitic field, 'false' if it is an instance field

Determines if this FieldReference refers to the specified Phoenix field symbol.

The Phoenix FieldSymbol to compare to this field reference 'true' if this field refers to the specified field symbol.

Determines if this FieldReference refers to the specified Phoenix static field symbol.

The Phoenix StaticFieldSymbol to compare to this field reference 'true' if this field refers to the specified static field symbol.

String representation of the field reference.

Represents a reference to a CLR method with a specified name.

Create a new NamedMethodReference object.

The type that contains the method. The name of the method, as it appears in metadata. 'true' if the method is an instance method, 'false' if it is a static method. The return type of the method. This may be null to indicate that the method returns void. The types of the parameters of the method (not including the 'this' parameter). The calling convention is assumed to be ClrCall.

Create a new NamedMethodReference object.

The type that contains the method. The name of the method, as it appears in metadata. The calling convention of the method. 'true' if the method is an instance method, 'false' if it is a static method. The return type of the method. This may be null to indicate that the method returns void. The types of the parameters of the method (not including the 'this' parameter).

Create a new NamedMethodReference object.

The type that contains the method. The name of the method, as it appears in metadata. The NamedMethodReference will match any method on the specified type with the specified name, regardless of signature.

Create a new NamedMethodReference object.

The type that contains the method. The name of the method, as it appears in metadata. The signature of the method.

Create a new NamedMethodReference object.

The type that contains the method. The name of the method, as it appears in metadata. The signature of the method. The types of the generic arguments of the method.

Determine if this method reference refers to the specified Phoenix method.

Phoenix FunctionSymbol to compare to this method reference. 'true' if this method reference refers to the specified FunctionSymbol.

String representation of the MethodReference.

A reference to a CLR type with a specific name.

Create a new NamedTypeReference object for a non-nested type.

The name of the type, as it appears in metadata (e.g. "System.Object", or "System.Collections.Generic.List`1").

Create a new NamedTypeReference object for a non-nested type.

The name of the type, as it appears in metadata (e.g. "System.Object", or "System.Collections.Generic.List`1"). The number of generic parameters this type takes.

Create a new NamedTypeReference object.

The name of the type, as it appears in metadata (e.g. "System.Object", or "System.Collections.Generic.List`1"). A type reference to the type that contains the type to be referred to, or null if the type is not nested.

Create a new NamedTypeReference object.

The name of the type, as it appears in metadata (e.g. "System.Object", or "System.Collections.Generic.List`1"). The number of generic parameters this type takes. A type reference to the type that contains the type to be referred to, or null if the type is not nested.

Determine if this type reference refers to the specified Phoenix type

Phoenix type to compare to this type reference. 'true' if this type reference refers to the specified type.

String representation of the TypeReference.

This is used for debugging only.

Extension methods for use with Phoenix operands.

Gets the of parameter that this operand defines, if any.

The operand to test. If the operand is the definition of a parameter, returns the . of the parameter being defined. Otherwise, returns null.

Gets the index of the parameter that this operand defines, if any.

The operand to test. If the operand is the definition of a parameter, returns the index. of the parameter being defined. Otherwise, returns null.

Returns true if this Operand is a null pointer operand.

The operand to test. Returns true if this Operand is a null pointer operand, false otherwise.

Returns the original operand definition if this operand was renamed during rename optimimzation.

The operand which replaced another operand in rename optimization. The definitionOperand of the original operand or null If replaced any operand during rename optimization it returns the definition Operand of the original operand Otherwise returns null.

Extension methods for use with Phoenix parameter symbols.

Determines if the specified parameter is a params array parameter.

The ParameterSymbol to be tested. 'true' if the specified parameter is a params array parameter.

Returns true if the named attribute is applied to this Symbol.

Symbol whose attributes are to be searched. A reference to the type of the attribute. True if the named attribute is applied to this Symbol.

Get the attribute on this symbol that matches the specified type.

Symbol whose attribute are to be searched. Type reference to the type of the attribute. The first matching AttributeSymbol, or null if none are found.

Finds all the attributes on this symbol that match the specified type.

Symbol whose attribute are to be searched. Type reference to the type of the attribute. List of the matching AttributeSymbols. List is empty if none are found.

Returns true if this is a ref or out parameter.

Gets the 0 based index of the parameter.

Index of the parameter or -1 if the parameter is not found. Reasons the parameter might not be found could be that it is this pointer or it if is not user defined.

Helper methods for the Phx.Symbols.ParameterSymbols type.

Get a list of the ParameterSymbol objects in a ParameterSymbols collection.

The ParameterSymbols collection. A list of the ParameterSymbol objects in the specified collection.

Represents a parsed format string used by methods such as System.String.Format.

Return a human-readable string representation of the format string.

A human-readable string representation of the format string.

List of the fixed text segments in this format string.

The number of fixed text segments is always one greater than the number of format items. A fixed text segment may consist of an empty string.

List of the format items in this format string.

Try to parse a format string.

The format string to be parsed. A ParsedFormatString object representing the parsed format string, or null if the format string could not be parsed.

Try to parse a format string.

The format string to be parsed. Set to the index of the first invalid character in the format string, or -1 if the format string is parsed successfully. A ParsedFormatString object representing the parsed format string, or null if the format string could not be parsed.

Represents a reference to a pointer type.

Create a new PointerTypeReference object.

Type reference for the type to which this pointer points. The pointer is assumed to be an ObjectPointer (e.g. "System.String ^").

Create a new PointerTypeReference object

Type reference for the type to which this pointer points. Kind of pointer.

Determine if this type reference refers to the specified Phoenix type

Phoenix type to compare to this type reference. 'true' if this type reference refers to the specified type.

String representation of the TypeReference.

This is used for debugging only.

Helper methods for the Phx.Symbols.PropertySymbol type.

Returns an IList of Phx.Symbols.FunctionArguments that represent the extra parameters this property takes. In other words this returns the parameters a property takes minus the value parameter all properties take.

Returns an IList of Phx.Symbols.FunctionArguments that represent the extra parameters this property takes.

Returns true if this PropertySymbol represents an indexer.

Returns whether or not this PropertySymbol is an indexer.

Represents a reference to a CLR generic argument list with specific argument types.

Create a new SpecificGenericArgumentListReference object.

The types of the generic arguments.

Determine if this generic argument list reference refers to the specified Phoenix generic argument list.

Phoenix TypeList to compare to this generic argument list reference. 'true' if this generic argument list reference refers to the specified argument list.

String representation of the GenericArgumentListReference.

This is used for debugging only.

Represents a reference to a CLR method signature with specific parameter types.

Create a new SpecificMethodSignatureReference object.

'true' if the method is an instance method, 'false' if it is a static method. The return type of the method. This may be null to indicate that the method returns void. The types of the parameters of the method (not including the 'this' parameter). The calling convention is assumed to be ClrCall.

Create a new SpecificMethodSignatureReference object.

The calling convention of the method. 'true' if the method is an instance method, 'false' if it is a static method. The return type of the method. This may be null to indicate that the method returns void. The types of the parameters of the method (not including the 'this' parameter).

Create a new SpecificMethodSignatureReference object.

The calling convention of the method. 'true' if the method is an instance method, 'false' if it is a static method. The number of generic arguments the method has (the generic arity). The return type of the method. This may be null to indicate that the method returns void. The types of the parameters of the method (not including the 'this' parameter).

Determine if this method signature reference refers to the specified Phoenix function type.

Phoenix FunctionType to compare to this method signature reference. 'true' if this method signature reference refers to the specified FunctionType.

String representation of the MethodSignatureReference.

This is used for debugging only.

Extension methods for use with Phoenix static field symbols.

Return true if the specified static field symbol is marked as compiler generated.

The static field symbol to test. 'true' if is compiler generated.

Extension methods for use with Phoenix symbols.

Returns true if the named attribute is applied to this Symbol.

Symbol whose attributes are to be searched. A reference to the type of the attribute. True if the named attribute is applied to this Symbol.

Returns true if at least one attribute matching the specified type is present in the list.

List of attributes to be searched. A reference to the type of the attribute. True if an attribute matching the specified type is present in the list.

Get the attribute that matches the specified type.

List of attributes to be searched. Type reference to the type of the attribute. The first matching AttributeSymbol, or null if none are found.

Finds all the attributes that match the specified type.

List of attributes to be searched. Type reference to the type of the attribute. List of the matching AttributeSymbols. List is empty if none are found.

Get the attribute on this symbol that matches the specified type.

Symbol whose attribute are to be searched. Type reference to the type of the attribute. The first matching AttributeSymbol, or null if none are found.

Finds all the attributes on this symbol that match the specified type.

Symbol whose attribute are to be searched. Type reference to the type of the attribute. List of the matching AttributeSymbols. List is empty if none are found.

Determine if the specified symbol is visible outside the assembly that contains it.

The symbol to test. 'true' if the symbol can be referenced from another assembly, 'false' otherwise. This method returns 'false' for any symbol that is only visible to a friend assembly.

Represents a reference to a CLR type.

Determine if this type reference refers to the specified Phoenix type

Phoenix type to compare to this type reference. 'true' if this type reference refers to the specified type.

Creates a PointerTypeReference to a NamedTypeReference.

The name of the type, as it appears in metadata (e.g. "System.Object", or "System.Collections.Generic.List`1"). PointerTypeReference to a NamedTypeReference

A reference to System.Array

A reference to System.Boolean.

A reference to System.Char.

A reference to System.Double.

A reference to System.Int8.

A reference to System.Int16.

A reference to System.Int32.

A reference to System.Int64.

A reference to System.Object.

A reference to System.Object^.

A reference to System.Nullable<T>.

A reference to any instantiation of System.Nullable<T>.

A reference to System.Single.

A reference to System.String.

A reference to System.String^.

A reference to System.Type.

A reference to System.Type^.

A reference to System.UInt8.

A reference to System.UInt16.

A reference to System.UInt32.

A reference to System.UInt64.

A reference to System.ValueType.

A reference to System.Void.

A reference to System.Exception.

A reference to System.ArgumentException.

A reference to System.Collections.Generic.IEnumerable`1

A reference to the Microsoft.VisualBasic.CompilerServices.Conversions

Dictionary that maps from Type to a user-specified value. The dictionary is populated using TypeReference objects as the keys, but lookup is done using Type objects as the keys.

Create a new TypeReferenceDictionary.

The default value for any type not in the dictionary is assumed to be default(TValue).

Create a new TypeReferenceDictionary.

The default value to be returned when looking up a type that is not in the dictionary.

Add a mapping from a TypeReference to a user-specified value.

Reference to the type to use as a key. User-specified value to map the type to.

Gets the value associated with a specified type.

Type for which the value is to be retrieved. The value associated with the specified type. If the type is not found, the return value is the default value specified in the constructor. If more than one key matches this type, one of the matching values will be returned, but it is undefined which one is actually returned.

Helper methods for the Phx.Types.TypeVariableType type.

Returns a collection of all the constraints applied to this type variable.

Returns true if this type variable is constrained to be a reference type.

Visits all of the aggregate types referenced by a type

A reference to a CLR type that will match a specific type variable.

Create a new TypeVariableTypeReference.

'true' if the reference should match a generic function parameter, 'false' if it should match a generic type parameter. Zero-based index of the parameter to match.

Determine if the specified Phoenix type refers to or derives from this type reference.

Phoenix type to compare. 'true' if the specified type is a TypeVariableType that matchines this reference.

String representation of the TypeVariableTypeReference.

This is used for debugging only.

An expression formatter for rendering Phoenix expressions as Visual Basic source code.

Gets the display name for the specified

The keyword to get the display name for. The display name of

Gets the display name for the specified

The Phoenix object to get the display name for. 's display name.

Gets the string to use for prefixing an array. "[" in C#.

Gets the string to use for suffixing an array. "]" in C#.

Gets the string to use to represent a bitwise OR operation. "|" in C#.

Gets the string to use for seperating the namespace name from the class name, or the class name from a static method name. "::" in C++.

Gets the string to use for seperating the class name from an instance method name when accessed through a pointer. "->" in C#.

Gets the string to use for seperating the class name from an instance method name when accessed through a reference. "." in C#.

Gets the string to use for declaring a managed pointer. "^" in C++.

Gets the string to use to represent a string concatenation operation. "+" in C#.

Primary constructor for a CSharpExpressionFormatter.

SharedParamArrayAnalysis to use for extracting individual arguments from a parameters array.

Formats a method call.

The call to format. The type that the destination of had when it it was used. The type that results in. An IFormatProvider to use in formatting the expression. The formatted method call.

Formats an isinst instruction as a use of the 'TryCast' operator.

The isinst instruction to format. The type that the variable argument to IsInst had when it it was used. The original type that the variable argument to IsInst was defined with. An IFormatProvider to use when formatting. "TryCast([var], [type])" where [var] is the variable be cast, and [type] is the destination type

Formats a conversion from one type to another.

Formats a floating point literal.

The value to format. The type of the literal. An IFormatProvider to use when formatting. The string representation of the float.

Formats a character literal.

The immediate to format. An IFormatProvider to use when formatting. The string represenation of the character.

Formats a character literal.

The character to format The IFormatProvider to use when formatting. The string representation of the character.

Formats a string immediate.

The string literal to format. An IFormatProvider to use when formatting. The escaped and formatted version of .

Format the default value of a value type.

The value type to format. An IFormatProvider to use when formatting. A string representation of the default value of the value type.

Format the default value of a type variable type.

The type variable type to format. An IFormatProvider to use when formatting. A string representation of the default value of the type variable type.

The type of the elements this array contains.

The size of each array dimension (rank).

The lower bounds of each array dimension (rank).

Gets the rank (number of dimensions) of the Array.

The parameters this delegate type takes.

The delegate type that a handler for this event must have. Corresponds to the type clause of C# event declaration.

The method to be called in order to add a handler to an event. Corresponds to the add clause of a C# event declaration.

The method to be called in order to remove a handler from an event. Corresponds to the remove clause of a C# event declaration.

The method that gets called to fire an event. There is no corresponding C# syntax (Does corespond to the Raise VB syntax).

The type of which this node is a member. Null if this node is a member of a Namespace.

The unqualified name of the member as it appears in IL.

The underlying Phoenix Object this type wraps.

The type of values that may be stored in the field.

Returns whether this field is static or not.

The type of which this node is a member. Null if this node is a member of a Namespace.

The unqualified name of the member as it appears in IL.

The underlying Phoenix Object this type wraps.

The name of the local variable. For example the name for "int myLocal;" is "myLocal".

The type of the local variable.

The underlying Phoenix Object this type wraps.

Provides the declaring event or property of an accessor, null if this method is not an accessor.

Collection of interface methods this method implements.

The parameters this method has to be called with.

The type of value that this method may return.

The (generic) method template from which this method was instantiated. Null if this is not a (generic) method template instance.

The arguments used when this (generic) method template instance was instantiated.

The template parameters for this (generic) method template definition.

The calling conventions defined for this method. For example VarArgs, C, StandardCall, etc.

The base class method this method overrides or null if this method does not override any base class methods.

Indicates that this method has a special name. For example operator overloads and constructors have special names.

Indicates if this method is an accessor for a property, indexer, or event. (For example the get and set methods for a property are considered accessors).

Indicates if this method is a instance initializer (instance constructor).

Indicates if this method is a static initializer (static constructor).

Indicates if this method is marked with the System.Runtime.CompilerServices.ExtensionAttribute attribute.

The unqualified name of the member as it appears in IL. Methods should just display their name with no namespace, parameters, or generic arity.

The underlying Phoenix Object this type wraps.

The full name of the type as it appears in IL (this includes the generic arity).

The full namespace of the type.

The generic template definition type for this type instance or null if this type is not generic.

The generic template arguments for a generic type instance.

The generic template parameters for a generic type definition.

Returns a list of type modifiers for this type or null if this type has no modifiers.

Indicates if this this type is marked with the System.Diagnostics.DebuggerDisplayAttribute attribute.

Returns the value of the "Type" named argument on the DebuggerDisplay attribute or null.

Is this type wrapped inside a Nullable type template. For example in the following code snippets "int? data1; int data2;" data1.TypeNode.IsInstantiationOfNullable == true but data2.TypeNode.IsInstantiationOfNullable == false

Is the system type.

Is System.ValueType or something that derives from it (like an enum or struct).

Is an enum type.

Is marked as "dynamic" via DynamicAttribute.

The type of which this node is a member. Null if this node is a member of a Namespace. A non null DeclaringType property on a type indicates that the type is a nested type.

The unqualified name of the member as it appears in IL. Types should just display their name plus their generic arity with no namespace.

The underlying Phoenix Object this type wraps.

The name of the parameter. For example the name for "Method(int myParameter)" is "myParameter".

The type of the parameter.

Indicates if this parameter is the this parameter. (As in the this parameter that is present on all instance methods).

Indicates if this parameter is a params array parameter (marked with ParamArrayAttribute). For example in "Method(int x, params string y)" 'y' is a params parameter but 'x' is not.

Indicates if this parameter is marked as an Out parameter. For example in "Method(int x, out int y)" 'y' is an out parameter but 'x' is not.

Indicates if this parameter is marked as an In parameter (By Value). By default parameters are normally In parameters unless they are marked by by ref or as Out parameters.

The parameter index for this parameter (0 indexed).

The the method this parameter belongs to.

The set of type elements in the parameter's type that are marked as dynamic.

The underlying Phoenix Object this type wraps.

The type pointed to by this pointer.

The type of this property (same as the return type of the getter for this property).

The get accessor method (get_[PropertyName]) for this property or null if this property does not have a getter.

The set accessor method (set_[PropertyName]) for this property or null if this property does not have a setter.

The extra parameters for this property. For normal properties this will be an empty collection. For indexers this will be the indexer parameters.

True if this property is an indexer property, false otherwise.

The type of which this node is a member.

The unqualified name of the member as it appears in IL.

The underlying Phoenix Object this type wraps.

The type refered to by this reference.

The type of values that may be stored in the field.

Returns whether this field is static or not.

The type of which this node is a member. Null if this node is a member of a Namespace.

The unqualified name of the member as it appears in IL.

The underlying Phoenix Object this type wraps.

The full name of the type as it appears in IL (this includes the generic arity).

The full namespace of the type.

The generic template definition type for this type instance or null if this type is not generic.

The generic template arguments for a generic type instance.

The generic template parameters for a generic type definition.

Returns a list of type modifiers for this type or null if this type has no modifiers.

Indicates if this this type is marked with the System.Diagnostics.DebuggerDisplayAttribute attribute.

Returns the value of the "Type" named argument on the DebuggerDisplay attribute or null.

Is the system type.

Is System.ValueType or something that derives from it (like an enum or struct).

Is an enum type.

Is marked as "dynamic" via DynamicAttribute.

The type of which this node is a member. Null if this node is a member of a Namespace. A non null DeclaringType property on a type indicates that the type is a nested type.

The unqualified name of the member as it appears in IL. Types should just display their name plus their generic arity with no namespace.

The underlying Phoenix Object this type wraps.

CCI (which the NameProviders were originally based on) will return an instanciated enclosing (declaring) type when a nested generic instanciation asks. Unfortunately that is not how it works in Reflection or IL, in reality it just uses the template enclosing type and it is possible for there to be no actual instanciation of the enclosing type. This type wraps a template type and gives the appearence of it being instanciated with a type argument.

Static factory class that converts Phoenix nodes into INodes used by the NameProviders.