ICSharpCode.NRefactory

Used to check the compatibility state of two compilations.

The ABI is equal

Some items got added, but the ABI remains to be compatible

The ABI has changed

The Abi comparer checks the public API of two compilation and determines the compatibility state.

Check the specified oldProject and newProject if they're compatible.

Old project. New project.

A graph where type definitions are nodes; and edges are given by inheritance.

Builds a graph of all type definitions in the specified set of assemblies.

The input assemblies. The assemblies may belong to multiple compilations. The resulting graph may be cyclic if there are cyclic type definitions.

Creates a new unconnected type graph node.

Represents a documentation comment.

Creates a new DocumentationComment.

The XML text. Context for resolving cref attributes.

Creates a new DocumentationComment.

The XML text. Context for resolving cref attributes.

Resolves the given cref value to an entity. Returns null if the entity is not found, or if the cref attribute is syntactically invalid.

Gets the XML code for this documentation comment.

A type reference of the form 'Some.Namespace.TopLevelType.NestedType`n'. We do not know the boundary between namespace name and top level type, so we have to try all possibilities. The type parameter count only applies to the innermost type, all outer types must be non-generic.

Represents a reference to a type. Must be resolved before it can be used as type.

Resolves this type reference.

Context to use for resolving this type reference. Which kind of context is required depends on the which kind of type reference this is; please consult the documentation of the method that was used to create this type reference, or that of the class implementing this method. Returns the resolved type. In case of an error, returns an unknown type (). Never returns null.

Provides XML documentation for entities.

Gets the XML documentation for the specified entity.

Provides XML documentation for entities.

Gets the XML documentation for the specified entity.

Gets the XML documentation for the specified entity.

A document representing a source code file for refactoring. Line and column counting starts at 1. Offset counting starts at 0.

A read-only view on a (potentially mutable) text source. The IDocument interface derives from this interface.

Creates an immutable snapshot of this text source. Unlike all other methods in this interface, this method is thread-safe.

Creates an immutable snapshot of a part of this text source. Unlike all other methods in this interface, this method is thread-safe.

Creates a new TextReader to read from this text source.

Creates a new TextReader to read from this text source.

Gets a character at the specified position in the document.

The index of the character to get. Offset is outside the valid range (0 to TextLength-1). The character at the specified position. This is the same as Text[offset], but is more efficient because it doesn't require creating a String object.

Retrieves the text for a portion of the document.

offset or length is outside the valid range. This is the same as Text.Substring, but is more efficient because it doesn't require creating a String object for the whole document.

Retrieves the text for a portion of the document.

offset or length is outside the valid range.

Writes the text from this document into the TextWriter.

Writes the text from this document into the TextWriter.

Gets the index of the first occurrence of the character in the specified array.

Character to search for Start index of the area to search. Length of the area to search. The first index where the character was found; or -1 if no occurrence was found.

Gets the index of the first occurrence of any character in the specified array.

Characters to search for Start index of the area to search. Length of the area to search. The first index where any character was found; or -1 if no occurrence was found.

Gets the index of the first occurrence of the specified search text in this text source.

The search text Start index of the area to search. Length of the area to search. String comparison to use. The first index where the search term was found; or -1 if no occurrence was found.

Gets the index of the last occurrence of the specified character in this text source.

The search character Start index of the area to search. Length of the area to search. The last index where the search term was found; or -1 if no occurrence was found. The search proceeds backwards from (startIndex+count) to startIndex. This is different than the meaning of the parameters on string.LastIndexOf!

Gets the index of the last occurrence of the specified search text in this text source.

The search text Start index of the area to search. Length of the area to search. String comparison to use. The last index where the search term was found; or -1 if no occurrence was found. The search proceeds backwards from (startIndex+count) to startIndex. This is different than the meaning of the parameters on string.LastIndexOf!

Gets a version identifier for this text source. Returns null for unversioned text sources.

Gets the total text length.

The length of the text, in characters. This is the same as Text.Length, but is more efficient because it doesn't require creating a String object.

Gets the whole text as string.

Creates an immutable snapshot of this document.

Gets the document line with the specified number.

The number of the line to retrieve. The first line has number 1.

Gets the document line that contains the specified offset.

Gets the offset from a text location.

Gets the offset from a text location.

Gets the location from an offset.

Inserts text.

The offset at which the text is inserted. The new text. Anchors positioned exactly at the insertion offset will move according to their movement type. For AnchorMovementType.Default, they will move behind the inserted text. The caret will also move behind the inserted text.

Inserts text.

The offset at which the text is inserted. The new text. Anchors positioned exactly at the insertion offset will move according to their movement type. For AnchorMovementType.Default, they will move behind the inserted text. The caret will also move behind the inserted text.

Inserts text.

The offset at which the text is inserted. The new text. Anchors positioned exactly at the insertion offset will move according to the anchor's movement type. For AnchorMovementType.Default, they will move according to the movement type specified by this parameter. The caret will also move according to the parameter.

Inserts text.

The offset at which the text is inserted. The new text. Anchors positioned exactly at the insertion offset will move according to the anchor's movement type. For AnchorMovementType.Default, they will move according to the movement type specified by this parameter. The caret will also move according to the parameter.

Removes text.

Starting offset of the text to be removed. Length of the text to be removed.

Replaces text.

The starting offset of the text to be replaced. The length of the text to be replaced. The new text.

Replaces text.

The starting offset of the text to be replaced. The length of the text to be replaced. The new text.

Make the document combine the following actions into a single action for undo purposes.

Ends the undoable action started with .

Creates an undo group. Dispose the returned value to close the undo group.

An object that closes the undo group when Dispose() is called.

Creates a new at the specified offset.

Gets/Sets the text of the whole document..

This event is called directly before a change is applied to the document.

It is invalid to modify the document within this event handler. Aborting the change (by throwing an exception) is likely to cause corruption of data structures that listen to the Changing and Changed events.

This event is called directly after a change is applied to the document.

It is invalid to modify the document within this event handler. Aborting the event handler (by throwing an exception) is likely to cause corruption of data structures that listen to the Changing and Changed events.

This event is called after a group of changes is completed.

Gets the number of lines in the document.

Gets the name of the file the document is stored in. Could also be a non-existent dummy file name or null if no name has been set.

Fired when the file name of the document changes.

A line inside a .

An (Offset,Length)-pair.

Gets the start offset of the segment.

Gets the length of the segment.

For line segments (IDocumentLine), the length does not include the line delimeter.

Gets the end offset of the segment.

EndOffset = Offset + Length;

Gets the length of this line, including the line delimiter.

Gets the length of the line terminator. Returns 1 or 2; or 0 at the end of the document.

Gets the number of this line. The first line has the number 1.

Gets the previous line. Returns null if this is the first line in the document.

Gets the next line. Returns null if this is the last line in the document.

Gets whether the line was deleted.

Extension methods for .

Gets whether fully contains the specified segment.

Use segment.Contains(offset, 0) to detect whether a segment (end inclusive) contains offset; use segment.Contains(offset, 1) to detect whether a segment (end exclusive) contains offset.

Gets whether fully contains the specified segment.

The TextAnchor class references an offset (a position between two characters). It automatically updates the offset when text is inserted/removed in front of the anchor.

Use the property to get the offset from a text anchor. Use the method to create an anchor from an offset. The document will automatically update all text anchors; and because it uses weak references to do so, the garbage collector can simply collect the anchor object when you don't need it anymore. Moreover, the document is able to efficiently update a large number of anchors without having to look at each anchor object individually. Updating the offsets of all anchors usually only takes time logarithmic to the number of anchors. Retrieving the property also runs in O(lg N). Usage: TextAnchor anchor = document.CreateAnchor(offset); ChangeMyDocument(); int newOffset = anchor.Offset;

Gets the text location of this anchor.

Thrown when trying to get the Offset from a deleted anchor.

Gets the offset of the text anchor.

Thrown when trying to get the Offset from a deleted anchor.

Controls how the anchor moves.

Anchor movement is ambiguous if text is inserted exactly at the anchor's location. Does the anchor stay before the inserted text, or does it move after it? The property will be used to determine which of these two options the anchor will choose. The default value is .

Specifies whether the anchor survives deletion of the text containing it. false: The anchor is deleted when the a selection that includes the anchor is deleted. true: The anchor is not deleted.

Gets whether the anchor was deleted.

When a piece of text containing an anchor is removed, then that anchor will be deleted. First, the property is set to true on all deleted anchors, then the events are raised. You cannot retrieve the offset from an anchor that has been deleted. This deletion behavior might be useful when using anchors for building a bookmark feature, but in other cases you want to still be able to use the anchor. For those cases, set = true.

Occurs after the anchor was deleted.

Due to the 'weak reference' nature of text anchors, you will receive the Deleted event only while your code holds a reference to the TextAnchor object.

Gets the line number of the anchor.

Thrown when trying to get the Offset from a deleted anchor.

Gets the column number of this anchor.

Thrown when trying to get the Offset from a deleted anchor.

Defines how a text anchor moves.

When text is inserted at the anchor position, the type of the insertion determines where the caret moves to. For normal insertions, the anchor will move after the inserted text.

Behaves like a start marker - when text is inserted at the anchor position, the anchor will stay before the inserted text.

Behave like an end marker - when text is insered at the anchor position, the anchor will move after the inserted text.

Represents a version identifier for a text source.

Verions can be used to efficiently detect whether a document has changed and needs reparsing; or even to implement incremental parsers. It is a separate class from ITextSource to allow the GC to collect the text source while the version checkpoint is still in use.

Gets whether this checkpoint belongs to the same document as the other checkpoint.

Returns false when given null.

Compares the age of this checkpoint to the other checkpoint.

This method is thread-safe. Raised if 'other' belongs to a different document than this version. -1 if this version is older than . 0 if this version instance represents the same version as . 1 if this version is newer than .

Gets the changes from this checkpoint to the other checkpoint. If 'other' is older than this checkpoint, reverse changes are calculated.

This method is thread-safe. Raised if 'other' belongs to a different document than this checkpoint.

Calculates where the offset has moved in the other buffer version.

Raised if 'other' belongs to a different document than this checkpoint.

Read-only implementation of .

Creates a new ReadOnlyDocument from the given text source.

Creates a new ReadOnlyDocument from the given string.

Creates a new ReadOnlyDocument from the given text source; and sets IDocument.FileName to the specified file name.

Will never be raised on .

Document based on a string builder. This class serves as a reference implementation for the IDocument interface.

Creates a new StringBuilderDocument.

Creates a new StringBuilderDocument with the specified initial text.

Creates a new StringBuilderDocument with the initial text copied from the specified text source.

Describes a change of the document text. This class is thread-safe.

Creates a new TextChangeEventArgs object.

Creates a new TextChangeEventArgs object.

Gets the new offset where the specified offset moves after this document change.

Creates TextChangeEventArgs for the reverse change.

The offset at which the change occurs.

The text that was removed.

The number of characters removed.

The text that was inserted.

The number of characters inserted.

Implements the ITextSource interface using a string.

Gets a text source containing the empty string.

Creates a new StringTextSource with the given text.

Creates a new StringTextSource with the given text.

Provides ITextSourceVersion instances.

Replaces the current version with a new version.

Change from current version to new version

Gets the current version.

Provides an interface to handle annotations in an object.

Gets the first annotation of the specified type. Returns null if no matching annotation exists.

The type of the annotation.

Gets the first annotation of the specified type. Returns null if no matching annotation exists.

The type of the annotation.

Adds an annotation to this instance.

The annotation to add.

Removes all annotations of the specified type.

The type of the annotations to remove.

Removes all annotations of the specified type.

The type of the annotations to remove.

Gets all annotations stored on this IAnnotatable.

Base class used to implement the IAnnotatable interface. This implementation is thread-safe.

Clones all annotations. This method is intended to be called by Clone() implementations in derived classes. AstNode copy = (AstNode)MemberwiseClone(); copy.CloneAnnotations();

Gets all annotations stored on this AstNode.

Container for the backtracking info.

Matches one of several alternatives.

Base class for all patterns.

AST node that supports pattern matching.

Gets the string that matches any string.

Matches any node.

Does not match null nodes.

Matches the last entry in the specified named group.

Performs a pattern matching operation. this is the pattern, is the AST that is being matched.

A match object. Check to see whether the match was successful. Patterns are ASTs that contain special pattern nodes (from the PatternMatching namespace). However, it is also possible to match two ASTs without any pattern nodes - doing so will produce a successful match if the two ASTs are structurally identical.

Represents the result of a pattern matching operation.

Represents a named node within a pattern.

Represents an optional node.

Provides documentation from an .xml file (as generated by the Microsoft C# compiler).

This class first creates an in-memory index of the .xml file, and then uses that to read only the requested members. This way, we avoid keeping all the documentation in memory. The .xml file is only opened when necessary, the file handle is not kept open all the time. If the .xml file is changed, the index will automatically be recreated.

Creates a new XmlDocumentationProvider.

Name of the .xml file. Error reading from XML file (or from redirected file) Invalid XML file

Given the assembly file name, looks up the XML documentation file name. Returns null if no XML documentation file is found.

Hash algorithm used for the index. This is a custom implementation so that old index files work correctly even when the .NET string.GetHashCode implementation changes (e.g. due to .NET 4.5 hash randomization)

Get the documentation for the member with the specified documentation key.

Hash code of the documentation tag

Position in the .xml file where the documentation starts

Represents the role a node plays within its parent.

Gets whether the specified node is valid in this role.

Gets the role with the specified index.

Represents the role a node plays within its parent. All nodes with this role have type T.

Gets the null object used when there's no node with this role. Not every role has a null object; this property returns null for roles without a null object.

Roles used for non-collections should always have a null object, so that no AST property returns null. However, if a role used for collections only, it may leave out the null object.

Represents an ambiguous type resolve result.

The resolved expression refers to a type name.

Represents the result of resolving an expression.

Represents an ambiguous field/property/event access.

Represents the result of a member invocation. Used for field/property/event access. Also, derives from MemberResolveResult.

Gets the member. This property never returns null.

Gets whether this MemberResolveResult is a virtual call.

Resolve result representing an array access.

Resolve result representing an array creation.

Gets the size arguments.

Gets the initializer elements. This field may be null if no initializer was specified.

Represents the resolve result of an 'ref x' or 'out x' expression.

ResolveResult representing a compile-time constant. Note: this class is mainly used for literals; there may be other ResolveResult classes which are compile-time constants as well. For example, a reference to a const field results in a . Check to determine is a resolve result is a constant.

Represents an implicit or explicit type conversion. conversionResolveResult.Input.Type is the source type; conversionResolveResult.Type is the target type. The property provides details about the kind of conversion.

For numeric conversions, specifies whether overflow checking is enabled.

Represents the 'sizeof'.

The type referenced by the 'sizeof'.

Represents a resolve error. Note: some errors are represented by other classes; for example a may be erroneous if the conversion is invalid.

.

Gets an ErrorResolveResult instance with Type = SpecialType.UnknownType.

Holds information about a conversion between two types.

Not a valid conversion.

Identity conversion.

The numeric conversion of a constant expression.

C# 'as' cast.

Gets whether the conversion is valid.

Gets whether the conversion is an 'as' cast.

Gets whether this conversion is a lifted version of another conversion.

Gets whether the conversion is dynamic.

Gets whether the conversion is a reference conversion.

Gets whether the conversion is an enumeration conversion.

Gets whether the conversion is a nullable conversion (conversion between a nullable type and the regular type).

Gets whether this conversion is user-defined (op_Implicit or op_Explicit).

The conversion that is applied to the input before the user-defined conversion operator is invoked.

The conversion that is applied to the result of the user-defined conversion operator.

Gets whether this conversion is a boxing conversion.

Gets whether this conversion is an unboxing conversion.

Gets whether this conversion is a pointer conversion.

Gets whether this conversion is a method group conversion.

For method-group conversions, gets whether to perform a virtual method lookup at runtime.

For method-group conversions, gets whether the conversion captures the first argument. For instance methods, this property always returns true for C# method-group conversions. For static methods, this property returns true for method-group conversions of an extension method performed on an instance (eg. Func<int> f = myEnumerable.Single).

Gets whether this conversion is an anonymous function conversion.

Gets the method associated with this conversion. For user-defined conversions, this is the method being called. For method-group conversions, this is the method that was chosen from the group.

Resolve result representing a 'foreach' loop.

Gets the semantic tree for the call to GetEnumerator.

Gets the collection type.

Gets the enumerator type.

Gets the element type. This is the type that would be inferred for an implicitly-typed element variable. For explicitly-typed element variables, this type may differ from ElementVariable.Type.

Gets the element variable.

Gets the Current property on the IEnumerator. Returns null if the property is not found.

Gets the MoveNext() method on the IEnumerator. Returns null if the method is not found.

Refers to the object that is currently being initialized. Used within .

Represents the result of a method, constructor or indexer invocation.

Gets the arguments that are being passed to the method, in the order the arguments are being evaluated.

Gets the list of initializer statements that are appplied to the result of this invocation. This is used to represent object and collection initializers. With the initializer statements, the is used to refer to the result of this invocation.

Gets the arguments in the order they are being passed to the method. For parameter arrays (params), this will return an ArrayCreateResolveResult.

Represents a local variable or parameter.

Represents a named argument.

Gets the member to which the parameter belongs. This field can be null.

Gets the parameter. This field can be null.

Gets the parameter name.

Gets the argument passed to the parameter.

Represents that an expression resolved to a namespace.

Represents a unary/binary/ternary operator invocation.

Gets the operator type.

Gets the operands.

Gets the user defined operator method. Returns null if this is a predefined operator.

Gets whether this is a lifted operator.

Represents the 'this' reference. Also used for the 'base' reference.

Gets whether this resolve result causes member invocations to be non-virtual.

Resolve result for a C# 'is' expression. "Input is TargetType".

Type that is being compared with.

Represents the 'typeof'.

The type referenced by the 'typeof'.

Represents an unknown member.

The type on which the method is being called.

Represents an unknown method.

Represents an unknown identifier.

A line/column position. Text editor lines/columns are counted started from one.

The document provides the methods and to convert between offsets and TextLocations.

Constant of the minimum line.

Constant of the minimum column.

Represents no text location (0, 0).

Creates a TextLocation instance.

Gets a string representation for debugging purposes.

Gets a hash code.

Equality test.

Equality test.

Equality test.

Inequality test.

Compares two text locations.

Compares two text locations.

Compares two text locations.

Compares two text locations.

Compares two text locations.

Gets the line number.

Gets the column number.

Gets whether the TextLocation instance is empty.

Enum that describes the accessibility of an entity.

The entity is completely inaccessible. This is used for C# explicit interface implementations.

The entity is only accessible within the same class.

The entity is accessible everywhere.

The entity is only accessible within the same class and in derived classes.

The entity is accessible within the same project content.

The entity is accessible both everywhere in the project content, and in all derived classes.

This corresponds to C# 'protected internal'.

The entity is accessible in derived classes within the same project content.

C# does not support this accessibility.

Gets the accessibility of this entity.

Gets a value indicating whether this instance is private.

true if this instance is private; otherwise, false.

Gets a value indicating whether this instance is public.

true if this instance is public; otherwise, false.

Gets a value indicating whether this instance is protected.

true if this instance is protected; otherwise, false.

Gets a value indicating whether this instance is internal.

true if this instance is internal; otherwise, false.

Gets a value indicating whether this instance is protected or internal.

true if this instance is protected or internal; otherwise, false.

Gets a value indicating whether this instance is protected and internal.

true if this instance is protected and internal; otherwise, false.

Anonymous type.

Default implementation for IType interface.

This interface represents a resolved type in the type system.

A type is potentially - a type definition (, i.e. a class, struct, interface, delegate, or built-in primitive type) - a parameterized type (, e.g. List<int>) - a type parameter (, e.g. T) - an array () - a pointer () - a managed reference () - one of the special types (, , , ) The property can be used to switch on the kind of a type. IType uses the null object pattern: serves as the null object. Methods or properties returning IType never return null unless documented otherwise. Types should be compared for equality using the method. Identical types do not necessarily use the same object reference.

Gets the fully qualified name of the class the return type is pointing to.

"System.Int32[]" for int[]
"System.Collections.Generic.List" for List<string> "System.Environment.SpecialFolder" for Environment.SpecialFolder

Gets the short name of the class the return type is pointing to.

"Int32[]" for int[]
"List" for List<string> "SpecialFolder" for Environment.SpecialFolder

Gets the full reflection name of the element.

For types, the reflection name can be parsed back into a ITypeReference by using . "System.Int32[]" for int[]
"System.Int32[][,]" for C# int[,][]
"System.Collections.Generic.List`1[[System.String]]" for List<string> "System.Environment+SpecialFolder" for Environment.SpecialFolder

Gets the full name of the namespace containing this entity.

Gets the underlying type definition. Can return null for types which do not have a type definition (for example arrays, pointers, type parameters).

Calls ITypeVisitor.Visit for this type.

The return value of the ITypeVisitor.Visit call

Calls ITypeVisitor.Visit for all children of this type, and reconstructs this type with the children based on the return values of the visit calls.

A copy of this type, with all children replaced by the return value of the corresponding visitor call. If the visitor returned the original types for all children (or if there are no children), returns this.

Creates a type reference that can be used to look up a type equivalent to this type in another compilation.

If this type contains open generics, the resulting type reference will need to be looked up in an appropriate generic context. Otherwise, the main resolve context of a compilation is sufficient.

Gets a type visitor that performs the substitution of class type parameters with the type arguments of this parameterized type. Returns TypeParameterSubstitution.Identity if the type is not parametrized.

Gets a type visitor that performs the substitution of class type parameters with the type arguments of this parameterized type, and also substitutes method type parameters with the specified method type arguments. Returns TypeParameterSubstitution.Identity if the type is not parametrized.

Gets inner classes (including inherited inner classes).

The filter used to select which types to return. The filter is tested on the original type definitions (before parameterization). Specified additional options for the GetMembers() operation. If the nested type is generic, this method will return a parameterized type, where the additional type parameters are set to . Type parameters belonging to the outer class will have the value copied from the outer type if it is a parameterized type. Otherwise, those existing type parameters will be self-parameterized, and thus 'leaked' to the caller in the same way the GetMembers() method does not specialize members from an and 'leaks' type parameters in member signatures. class Base<T> { class Nested<X> {} } class Derived<A, B> : Base<B> {} Derived[string,int].GetNestedTypes() = { Base`1+Nested`1[int, unbound] } Derived.GetNestedTypes() = { Base`1+Nested`1[`1, unbound] } Base[`1].GetNestedTypes() = { Base`1+Nested`1[`1, unbound] } Base.GetNestedTypes() = { Base`1+Nested`1[`0, unbound] }

Gets inner classes (including inherited inner classes) that have typeArguments.Count additional type parameters.

The type arguments passed to the inner class The filter used to select which types to return. The filter is tested on the original type definitions (before parameterization). Specified additional options for the GetMembers() operation. Type parameters belonging to the outer class will have the value copied from the outer type if it is a parameterized type. Otherwise, those existing type parameters will be self-parameterized, and thus 'leaked' to the caller in the same way the GetMembers() method does not specialize members from an and 'leaks' type parameters in member signatures.

Gets all instance constructors for this type.

The filter used to select which constructors to return. The filter is tested on the original method definitions (before specialization). Specified additional options for the GetMembers() operation. The result does not include static constructors. Constructors in base classes are not returned by default, as GetMemberOptions.IgnoreInheritedMembers is the default value. For methods on parameterized types, type substitution will be performed on the method signature, and the appropriate will be returned.

Gets all methods that can be called on this type.

The filter used to select which methods to return. The filter is tested on the original method definitions (before specialization). Specified additional options for the GetMembers() operation. The result does not include constructors or accessors. For methods on parameterized types, type substitution will be performed on the method signature, and the appropriate will be returned. If the method being returned is generic, and this type is a parameterized type where the type arguments involve another method's type parameters, the resulting specialized signature will be ambiguous as to which method a type parameter belongs to. For example, "List[[``0]].GetMethods()" will return "ConvertAll(Converter`2[[``0, ``0]])". If possible, use the other GetMethods() overload to supply type arguments to the method, so that both class and method type parameter can be substituted at the same time, so that the ambiguity can be avoided.

Gets all generic methods that can be called on this type with the specified type arguments.

The type arguments used for the method call. The filter used to select which methods to return. The filter is tested on the original method definitions (before specialization). Specified additional options for the GetMembers() operation. The result does not include constructors or accessors. Type substitution will be performed on the method signature, creating a with the specified type arguments. When the list of type arguments is empty, this method acts like the GetMethods() overload without the type arguments parameter - that is, it also returns generic methods, and the other overload's remarks about ambiguous signatures apply here as well.

Gets all properties that can be called on this type.

The filter used to select which properties to return. The filter is tested on the original property definitions (before specialization). Specified additional options for the GetMembers() operation. For properties on parameterized types, type substitution will be performed on the property signature, and the appropriate will be returned.

Gets all fields that can be accessed on this type.

The filter used to select which constructors to return. The filter is tested on the original field definitions (before specialization). Specified additional options for the GetMembers() operation. For fields on parameterized types, type substitution will be performed on the field's return type, and the appropriate will be returned.

Gets all events that can be accessed on this type.

The filter used to select which events to return. The filter is tested on the original event definitions (before specialization). Specified additional options for the GetMembers() operation. For fields on parameterized types, type substitution will be performed on the event's return type, and the appropriate will be returned.

Gets all members that can be called on this type.

The filter used to select which members to return. The filter is tested on the original member definitions (before specialization). Specified additional options for the GetMembers() operation. The resulting list is the union of GetFields(), GetProperties(), GetMethods() and GetEvents(). It does not include constructors. For parameterized types, type substitution will be performed. For generic methods, the remarks about ambiguous signatures from the method apply here as well.

Gets all accessors belonging to properties or events on this type.

The filter used to select which members to return. The filter is tested on the original member definitions (before specialization). Specified additional options for the GetMembers() operation. Accessors are not returned by GetMembers() or GetMethods().

Gets the type kind.

Gets whether the type is a reference type or value type.

true, if the type is a reference type. false, if the type is a value type. null, if the type is not known (e.g. unconstrained generic type parameter or type not found)

Gets the parent type, if this is a nested type. Returns null for top-level types.

Gets the number of type parameters.

Gets the type arguments passed to this type. If this type is a generic type definition that is not parameterized, this property returns the type parameters, as if the type was parameterized with its own type arguments (class C<T> { C<T> field; }). NOTE: The type will change to IReadOnlyList<IType> in future versions.

If true the type represents an instance of a generic type.

Gets the direct base types.

Returns the direct base types including interfaces

Implementation of that resolves an unresolved member.

Implementation of that resolves an unresolved entity.

Represents a resolved entity.

Interface for type system symbols.

Creates a symbol reference that can be used to rediscover this symbol in another compilation.

This property returns an enum specifying which kind of symbol this is (which derived interfaces of ISymbol are implemented)

Gets the short name of the symbol.

Gets the parent compilation. This property never returns null.

Gets the entity type.

Gets the short name of the entity.

Gets the complete entity region (including header+body)

Gets the entity body region.

Gets the declaring class. For members, this is the class that contains the member. For nested classes, this is the outer class. For top-level entities, this property returns null.

Gets/Sets the declaring type (incl. type arguments, if any). This property never returns null -- for top-level entities, it returns SharedTypes.UnknownType. If this is not a specialized member, the value returned is equal to .

The assembly in which this entity is defined. This property never returns null.

Gets the attributes on this entity.

Gets the documentation for this entity.

Gets whether this entity is static. Returns true if either the 'static' or the 'const' modifier is set.

Returns whether this entity is abstract.

Static classes also count as abstract classes.

Returns whether this entity is sealed.

Static classes also count as sealed classes.

Gets whether this member is declared to be shadowing another member with the same name. (C# 'new' keyword)

Gets whether this member is generated by a macro/compiler feature.

Method/field/property/event.

Creates a member reference that can be used to rediscover this member in another compilation.

If this member is specialized using open generic types, the resulting member reference will need to be looked up in an appropriate generic context. Otherwise, the main resolve context of a compilation is sufficient.

Creates a member reference that can be used to rediscover this member in another compilation.

If this member is specialized using open generic types, the resulting member reference will need to be looked up in an appropriate generic context. Otherwise, the main resolve context of a compilation is sufficient.

Specializes this member with the given substitution. If this member is already specialized, the new substitution is composed with the existing substition.

Gets the original member definition for this member. Returns this if this is not a specialized member. Specialized members are the result of overload resolution with type substitution.

Gets the unresolved member instance from which this member was created. This property may return null for special members that do not have a corresponding unresolved member instance.

For specialized members, this property returns the unresolved member for the original member definition. For partial methods, this property returns the implementing partial method declaration, if one exists, and the defining partial method declaration otherwise. For the members used to represent the built-in C# operators like "operator +(int, int);", this property returns null.

Gets the return type of this member. This property never returns null.

Gets the interface members implemented by this member (both implicitly and explicitly).

Gets whether this member is explicitly implementing an interface.

Gets if the member is virtual. Is true only if the "virtual" modifier was used, but non-virtual members can be overridden, too; if they are abstract or overriding a method.

Gets whether this member is overriding another member.

Gets if the member can be overridden. Returns true when the member is "abstract", "virtual" or "override" but not "sealed".

Gets the substitution belonging to this specialized member. Returns TypeParameterSubstitution.Identity for not specialized members.

Represents a property or indexer.

Represents a method or property.

Default implementation of that resolves an unresolved method.

Represents a method, constructor, destructor or operator.

Specializes this method with the given substitution. If this method is already specialized, the new substitution is composed with the existing substition.

Gets the unresolved method parts. For partial methods, this returns all parts. Otherwise, this returns an array with a single element (new[] { UnresolvedMember }). NOTE: The type will change to IReadOnlyList<IUnresolvedMethod> in future versions.

Gets the attributes associated with the return type. (e.g. [return: MarshalAs(...)]) NOTE: The type will change to IReadOnlyList<IAttribute> in future versions.

Gets the type parameters of this method; or an empty list if the method is not generic. NOTE: The type will change to IReadOnlyList<ITypeParameter> in future versions.

Gets whether this is a generic method that has been parameterized.

Gets the type arguments passed to this method. If the method is generic but not parameterized yet, this property returns the type parameters, as if the method was parameterized with its own type arguments (void M<T>() { M<T>(); }). NOTE: The type will change to IReadOnlyList<IType> in future versions.

Gets whether the method is a C#-style partial method. A call to such a method is ignored by the compiler if the partial method has no body.

Gets whether the method is a C#-style async method.

Gets whether the method has a body. This property returns false for abstract or extern methods, or for partial methods without implementation.

Gets whether the method is a property/event accessor.

If this method is an accessor, returns the corresponding property/event. Otherwise, returns null.

If this method is reduced from an extension method return the original method, null otherwise. A reduced method doesn't contain the extension method parameter. That means that has one parameter less than it's definition.

Gets a dummy constructor for the specified compilation.

A public instance constructor with IsSynthetic=true and no declaring type.

Gets a dummy constructor for the specified type.

A public instance constructor with IsSynthetic=true and the specified declaring type.

Anonymous type reference.

Represents an array type.

Interface for TypeSystem objects that support interning. See for more information.

Gets a hash code for interning.

Equality test for interning.

Helper methods for COM.

Gets whether the specified type is imported from COM.

Gets the CoClass of the specified COM interface.

Default implementation of ISolutionSnapshot.

Represents a snapshot of the whole solution (multiple compilations).

Gets the project content with the specified file name. Returns null if no such project exists in the solution.

This method is used by the class.

Gets the compilation for the specified project. The project must be a part of the solution (passed to the solution snapshot's constructor).

Creates a new DefaultSolutionSnapshot with the specified projects.

Creates a new DefaultSolutionSnapshot that does not support s.

Returns true, if the given coordinates (line, column) are in the region. This method assumes that for an unknown end the end line is == -1 Returns true, if the given coordinates (line, column) are in the region. This method assumes that for an unknown end the end line is == -1 if the end line is == -1 the end column is -1 too this stands for an unknwon end if the end column is == -1 the end line is -1 too this stands for an unknown end

The symbol is a property, but not an indexer.

The symbol is an indexer, not a regular property.

The symbol is a method which is not an operator/constructor/destructor or accessor.

The symbol is a user-defined operator.

The accessor method for a property getter/setter or event add/remove.

Gets the current assembly. This property may return null if this context does not specify any assembly.

Gets the current type definition.

Gets the current member.

Gets all currently visible local variables and lambda parameters. Does not include method parameters.

Gets whether the context is within a lambda expression or anonymous method.

Default implementation of .

Represents a variable (name/type pair).

Gets the name of the variable.

Gets the declaration region of the variable.

Gets the type of the variable.

Gets whether this variable is a constant (C#-like const).

If this field is a constant, retrieves the value. For parameters, this is the default value.

Represents an attribute.

Gets the code region of this attribute.

Gets the type of the attribute.

Gets the constructor being used. This property may return null if no matching constructor was found.

Gets the positional arguments.

Gets the named arguments passed to the attribute.

IUnresolvedAttribute implementation that loads the arguments from a binary blob.

Represents an unresolved attribute.

Resolves the attribute.

Gets the code region of this attribute.

The symbol is a property, but not an indexer.

The symbol is an indexer, not a regular property.

The symbol is a method which is not an operator/constructor/destructor or accessor.

The symbol is a user-defined operator.

The accessor method for a property getter/setter or event add/remove.

The symbol is a variable, but not a parameter.

Helper class for dealing with System.Threading.Tasks.Task.

Gets the T in Task<T>. Returns void for non-generic Task. Any other type is returned unmodified.

Gets whether the specified type is Task or Task<T>.

Creates a task type.

Substitutes class and method type parameters.

Base class for the visitor pattern on .

The identity function.

Creates a new type parameter substitution.

The type arguments to substitute for class type parameters. Pass null to keep class type parameters unmodified. The type arguments to substitute for method type parameters. Pass null to keep method type parameters unmodified.

Computes a single TypeParameterSubstitution so that for all types t: t.AcceptVisitor(Compose(g, f)) equals t.AcceptVisitor(f).AcceptVisitor(g)

If you consider type parameter substitution to be a function, this is function composition.

Gets the list of class type arguments. Returns null if this substitution keeps class type parameters unmodified.

Gets the list of method type arguments. Returns null if this substitution keeps method type parameters unmodified.

Contains extension methods for the type system.

Gets all base types.

This is the reflexive and transitive closure of . Note that this method does not return all supertypes - doing so is impossible due to contravariance (and undesirable for covariance as the list could become very large). The output is ordered so that base types occur before derived types.

Gets all non-interface base types.

When is an interface, this method will also return base interfaces (return same output as GetAllBaseTypes()). The output is ordered so that base types occur before derived types.

Gets all base type definitions. The output is ordered so that base types occur before derived types.

This is equivalent to type.GetAllBaseTypes().Select(t => t.GetDefinition()).Where(d => d != null).Distinct().

Gets whether this type definition is derived from the base type definition.

Gets whether this type definition is derived from a given known type.

Gets whether the type is an open type (contains type parameters).

class X<T> { List<T> open; X<X<T[]>> open; X<string> closed; int closed; }

Gets the entity that owns the type parameters occurring in the specified type. If both class and method type parameters are present, the method is returned. Returns null if the specified type is closed.

Gets whether the type is unbound (is a generic type, but no type arguments were provided).

In "typeof(List<Dictionary<,>>)", only the Dictionary is unbound, the List is considered bound despite containing an unbound type. This method returns false for partially parameterized types (Dictionary<string, >).

Gets whether the type is the specified known type. For generic known types, this returns true any parameterization of the type (and also for the definition itself).

Imports a symbol from another compilation.

Imports a type from another compilation.

Imports a type from another compilation.

Imports an entity from another compilation.

Imports a member from another compilation.

Imports a member from another compilation.

Imports a member from another compilation.

Imports a member from another compilation.

Imports a member from another compilation.

Imports a namespace from another compilation.

This method may return null if the namespace does not exist in the target compilation.

Gets the invoke method for a delegate type.

Returns null if the type is not a delegate type; or if the invoke method could not be found.

Gets all unresolved type definitions from the file. For partial classes, each part is returned.

Gets all unresolved type definitions from the assembly. For partial classes, each part is returned.

Gets all type definitions in the compilation. This may include types from referenced assemblies that are not accessible in the main assembly.

Gets all top level type definitions in the compilation. This may include types from referenced assemblies that are not accessible in the main assembly.

Gets the type (potentially a nested type) defined at the specified location. Returns null if no type is defined at that location.

Gets the member defined at the specified location. Returns null if no member is defined at that location.

Gets all sub type definitions defined in a context.

Retrieves the specified type in this compilation. Returns an if the type cannot be found in this compilation.

There can be multiple types with the same full name in a compilation, as a full type name is only unique per assembly. If there are multiple possible matches, this method will return just one of them. When possible, use instead to retrieve a type from a specific assembly.

Gets the type definition for the specified unresolved type. Returns null if the unresolved type does not belong to this assembly.

Resolves a type reference in the compilation's main type resolve context. Some type references require a more specific type resolve context and will not resolve using this method.

Returns the resolved type. In case of an error, returns . Never returns null.

Gets the attribute of the specified attribute type (or derived attribute types).

The entity on which the attributes are declared. The attribute type to look for. Specifies whether attributes inherited from base classes and base members (if the given in an override) should be returned. The default is true. Returns the attribute that was found; or null if none was found. If inherit is true, an from the entity itself will be returned if possible; and the base entity will only be searched if none exists.

Gets the attributes of the specified attribute type (or derived attribute types).

The entity on which the attributes are declared. The attribute type to look for. Specifies whether attributes inherited from base classes and base members (if the given in an override) should be returned. The default is true. Returns the list of attributes that were found. If inherit is true, attributes from the entity itself are returned first; followed by attributes inherited from the base entity.

Gets the attribute of the specified attribute type (or derived attribute types).

The entity on which the attributes are declared. The attribute type to look for. Specifies whether attributes inherited from base classes and base members (if the given in an override) should be returned. The default is true. Returns the attribute that was found; or null if none was found. If inherit is true, an from the entity itself will be returned if possible; and the base entity will only be searched if none exists.

Gets the attributes of the specified attribute type (or derived attribute types).

The entity on which the attributes are declared. The attribute type to look for. Specifies whether attributes inherited from base classes and base members (if the given in an override) should be returned. The default is true. Returns the list of attributes that were found. If inherit is true, attributes from the entity itself are returned first; followed by attributes inherited from the base entity.

Gets the attribute of the specified attribute type (or derived attribute types).

The entity on which the attributes are declared. Specifies whether attributes inherited from base classes and base members (if the given in an override) should be returned. The default is true. Returns the attribute that was found; or null if none was found. If inherit is true, an from the entity itself will be returned if possible; and the base entity will only be searched if none exists.

Gets the type definition for a top-level type.

This method uses ordinal name comparison, not the compilation's name comparer.

Holds the full name of a type definition. A full type name uniquely identifies a type definition within a single assembly.

A full type name can only represent type definitions, not arbitrary types. It does not include any type arguments, and can not refer to array or pointer types. A full type name represented as reflection name has the syntax: NamespaceName '.' TopLevelTypeName ['`'#] { '+' NestedTypeName ['`'#] }

Constructs a FullTypeName representing the given top-level type.

FullTypeName has an implicit conversion operator from TopLevelTypeName, so you can simply write: FullTypeName f = new TopLevelTypeName(...);

Constructs a FullTypeName by parsing the given reflection name. Note that FullTypeName can only represent type definition names. If the reflection name might refer to a parameterized type or array etc., use instead.

Expected syntax: NamespaceName '.' TopLevelTypeName ['`'#] { '+' NestedTypeName ['`'#] } where # are type parameter counts

Gets the name of the nested type at the given level.

Gets the number of additional type parameters of the nested type at the given level.

Gets the declaring type name.

This is a top-level type name. new FullTypeName("NS.A+B+C").GetDeclaringType() will return new FullTypeName("NS.A+B")

Creates a nested type name.

new FullTypeName("NS.A+B").NestedType("C", 1) will return new FullTypeName("NS.A+B+C`1")

Gets the top-level type name.

Gets whether this is a nested type.

Gets the nesting level.

Gets the name of the type. For nested types, this is the name of the innermost type.

Gets the total type parameter count.

Convert only the name.

Show the parameter list

Show names for parameters

Show the accessibility (private, public, etc.)

Show the definition key word (class, struct, Sub, Function, etc.)

Show the declaring type for the member

Show modifiers (virtual, override, etc.)

Show the return type

Use fully qualified names for types.

Show the list of type parameters on method and class declarations. Type arguments for parameter/return types are always shown.

For fields, events and methods: adds a semicolon at the end. For properties: shows "{ get; }" or similar.

Use fully qualified names for members.

Ambiences are used to convert type system symbols to text (usually for displaying the symbol to the user; e.g. in editor tooltips).

Represents an unresolved assembly.

Resolves this assembly.

Gets the assembly name (short name).

Gets the full assembly name (including public key token etc.)

Gets the path to the assembly location. For projects it is the same as the output path.

Gets the list of all assembly attributes in the project.

Gets the list of all module attributes in the project.

Gets all non-nested types in the assembly.

Represents an assembly.

Gets whether the internals of this assembly are visible in the specified assembly.

Gets the type definition for a top-level type.

This method uses ordinal name comparison, not the compilation's name comparer.

Gets the original unresolved assembly.

Gets whether this assembly is the main assembly of the compilation.

Gets the assembly name (short name).

Gets the full assembly name (including public key token etc.)

Gets the list of all assembly attributes in the project.

Gets the list of all module attributes in the project.

Gets the root namespace for this assembly.

This always is the namespace without a name - it's unrelated to the 'root namespace' project setting.

Gets all non-nested types in the assembly.

Gets the root namespace for a given extern alias.

If is null or an empty string, this method returns the global root namespace. If no alias with the specified name exists, this method returns null.

Gets the current assembly.

Gets the type resolve context that specifies this compilation and no current assembly or entity.

Gets the list of all assemblies in the compilation.

This main assembly is the first entry in the list.

Gets the referenced assemblies. This list does not include the main assembly.

Gets the root namespace of this compilation. This is a merged version of the root namespaces of all assemblies.

This always is the namespace without a name - it's unrelated to the 'root namespace' project setting.

Gets the name comparer for the language being compiled. This is the string comparer used for the INamespace.GetTypeDefinition method.

Represents an unresolved constant value.

Resolves the value of this constant.

Context where the constant value will be used. Resolve result representing the constant value. This method never returns null; in case of errors, an ErrorResolveResult will be returned.

Represents an unresolved entity.

Gets the entity type.

Gets the complete entity region (including header+body)

Gets the entity body region.

Gets the declaring class. For members, this is the class that contains the member. For nested classes, this is the outer class. For top-level entities, this property returns null.

Gets the parsed file in which this entity is defined. Returns null if this entity wasn't parsed from source code (e.g. loaded from a .dll with CecilLoader).

Gets the attributes on this entity.

Gets whether this entity is static. Returns true if either the 'static' or the 'const' modifier is set.

Returns whether this entity is abstract.

Static classes also count as abstract classes.

Returns whether this entity is sealed.

Static classes also count as sealed classes.

Gets whether this member is declared to be shadowing another member with the same name.

Gets whether this member is generated by a macro/compiler feature.

Method/field/property/event.

Resolves the member.

Context to use for resolving this member reference. Which kind of context is required depends on the which kind of member reference this is; please consult the documentation of the method that was used to create this member reference, or that of the class implementing this method. Returns the resolved member, or null if the member could not be found.

Gets the declaring type reference for the member.

Resolves the member.

Context for looking up the member. The context must specify the current assembly. A that specifies the current assembly is sufficient. Returns the resolved member, or null if the member could not be found.

Creates the resolved member.

The language-specific context that includes the parent type definition.

Gets the return type of this member. This property never returns null.

Gets whether this member is explicitly implementing an interface. If this property is true, the member can only be called through the interfaces it implements.

Gets the interfaces that are explicitly implemented by this member.

Gets if the member is virtual. Is true only if the "virtual" modifier was used, but non-virtual members can be overridden, too; if they are abstract or overriding a method.

Gets whether this member is overriding another member.

Gets if the member can be overridden. Returns true when the member is "abstract", "virtual" or "override" but not "sealed".

Resolves the member.

Context for looking up the member. The context must specify the current assembly. A that specifies the current assembly is sufficient. Returns the resolved member, or null if the member could not be found.

Represents a field or constant.

Resolves the member.

Context for looking up the member. The context must specify the current assembly. A that specifies the current assembly is sufficient. Returns the resolved member, or null if the member could not be found.

Gets whether this field is readonly.

Gets whether this field is volatile.

Gets whether this field is a constant (C#-like const).

Gets whether this field is a fixed size buffer (C#-like fixed). If this is true, then ConstantValue contains the size of the buffer.

Represents a field or constant.

Gets the name of the field.

Gets the region where the field is declared.

Gets whether this field is readonly.

Gets whether this field is volatile.

Gets whether this field is a fixed size buffer (C#-like fixed). If this is true, then ConstantValue contains the size of the buffer.

Freezes this instance.

Gets if this instance is frozen. Frozen instances are immutable and thus thread-safe.

Provider used for interning.

A simple IInterningProvider implementation could use 3 dictionaries: 1. using value equality comparer (for certain types known to implement value equality, e.g. string and IType) 2. using comparer that calls into ISupportsInterning (for types implementing ISupportsInterning) 3. list comparer (for InternList method) On the first Intern()-call, the provider tells the object to prepare for interning (ISupportsInterning.PrepareForInterning) and stores it into a dictionary. On further Intern() calls, the original object is returned for all equal objects. This allows reducing the memory usage by using a single object instance where possible. Interning provider implementations could also use the interning logic for different purposes: for example, it could be used to determine which objects are used jointly between multiple type definitions and which are used only within a single type definition. Then a persistent file format could be organized so that shared objects are loaded only once, yet non-shared objects get loaded lazily together with the class.

Interns the specified object. If the object is freezable, it will be frozen.

Interns the specified object. If the object is freezable, it will be frozen.

Interns the specified string.

Inters a boxed value type.

Interns the given list. Uses reference equality to compare the list elements.

Represents a method or property.

Resolves the member.

Context for looking up the member. The context must specify the current assembly. A that specifies the current assembly is sufficient. Returns the resolved member, or null if the member could not be found.

Gets the attributes associated with the return type. (e.g. [return: MarshalAs(...)])

Gets whether the method is a C#-style partial method. Check to test if it is a partial method declaration or implementation.

Gets whether the method is a C#-style async method.

Gets whether the method has a body. This property returns false for abstract or extern methods, or for partial methods without implementation.

If this method is an accessor, returns a reference to the corresponding property/event. Otherwise, returns null.

If the item is not frozen, this method creates and returns a frozen clone. If the item is already frozen, it is returned without creating a clone.

Freezes this instance.

Gets if this instance is frozen. Frozen instances are immutable and thus thread-safe.

Type parameter of a generic class/method.

Get the type of this type parameter's owner.

SymbolKind.TypeDefinition or SymbolKind.Method

Gets the owning method/class. This property may return null (for example for the dummy type parameters used by ).

For "class Outer<T> { class Inner {} }", inner.TypeParameters[0].Owner will be the outer class, because the same ITypeParameter instance is used both on Outer`1 and Outer`1+Inner.

Gets the index of the type parameter in the type parameter list of the owning method/class.

Gets the name of the type parameter.

Gets the list of attributes declared on this type parameter.

Gets the variance of this type parameter.

Gets the region where the type parameter is defined.

Gets the effective base class of this type parameter.

Gets the effective interface set of this type parameter.

Gets if the type parameter has the 'new()' constraint.

Gets if the type parameter has the 'class' constraint.

Gets if the type parameter has the 'struct' constraint.

Base class for implementations.

Uses the specified interning provider to intern strings and lists in this entity. This method does not test arbitrary objects to see if they implement ISupportsInterning; instead we assume that those are interned immediately when they are created (before they are added to this entity).

Creates a shallow clone of this entity. Collections (e.g. a type's member list) will be cloned as well, but the elements of said list will not be. If this instance is frozen, the clone will be unfrozen.

Base class for implementations.

Given a reference to an accessor, returns the accessor's owner.

Helper class for the GetAllBaseTypes() implementation.

If this option is enabled, the list will not contain interfaces when retrieving the base types of a class.

References an existing assembly by name.

IAttribute implementation for already-resolved attributes.

References an entity by its type and name. This class can be used to refer to all members except for constructors and explicit interface implementations.

Resolving a DefaultMemberReference requires a context that provides enough information for resolving the declaring type reference and the parameter types references.

Default implementation of .

Gets the list of attributes.

Gets whether this parameter is a C# 'ref' parameter.

Gets whether this parameter is a C# 'out' parameter.

Gets whether this parameter is a C# 'params' parameter.

Gets whether this parameter is optional. The default value is given by the property.

Gets the owner of this parameter. May return null; for example when parameters belong to lambdas or anonymous methods.

Default implementation of .

Represents a class, enum, interface, struct, delegate or VB module. For partial classes, this represents the whole class.

Determines how this type is implementing the specified interface member.

The method on this type that implements the interface member; or null if the type does not implement the interface.

Determines how this type is implementing the specified interface members.

For each interface member, this method returns the class member that implements the interface member. For interface members that are missing an implementation, the result collection will contain a null element.

Returns all parts that contribute to this type definition. Non-partial classes have a single part that represents the whole class.

Gets the known type code for this type definition.

For enums: returns the underlying primitive type. For all other types: returns .

Gets the full name of this type.

Gets/Sets the declaring type (incl. type arguments, if any). This property never returns null -- for top-level entities, it returns SharedTypes.UnknownType.

Gets whether this type contains extension methods.

This property is used to speed up the search for extension methods.

Gets whether this type definition is made up of one or more partial classes.

Default implementation for .

Creates a new unresolved assembly.

Full assembly name

Adds a new top-level type definition to this assembly.

DefaultUnresolvedAssembly does not support partial classes. Adding more than one part of a type will cause an ArgumentException.

Adds a type forwarder. This adds both an assembly attribute and an internal forwarder entry, which will be used by the resolved assembly to provide the forwarded types.

The name of the type. The reference used to look up the type in the target assembly.

Gets/Sets the short assembly name.

This class handles the short and the full name independently; if you change the short name, you should also change the full name.

Gets/Sets the full assembly name.

This class handles the short and the full name independently; if you change the full name, you should also change the short name.

Represents a resolved namespace.

Gets a direct child namespace by its short name. Returns null when the namespace cannot be found.

This method uses the compilation's current string comparer.

Gets the type with the specified short name and type parameter count. Returns null if the type cannot be found.

This method uses the compilation's current string comparer.

Gets the extern alias for this namespace. Returns an empty string for normal namespaces.

Gets the full name of this namespace. (e.g. "System.Collections")

Gets the short name of this namespace (e.g. "Collections").

Gets the parent namespace. Returns null if this is the root namespace.

Gets the child namespaces in this namespace.

Gets the types in this namespace.

Gets the assemblies that contribute types to this namespace (or to child namespaces).

Default implementation of .

Default implementation of .

Default implementation of .

Default implementation of interface.

Returns a dummy constructor instance:

A public instance constructor with IsSynthetic=true and no declaring type.

Default implementation for IUnresolvedParameter.

Gets the name of the variable.

Gets the declaration region of the variable.

Gets the type of the variable.

Gets the list of attributes.

Gets whether this parameter is a C# 'ref' parameter.

Gets whether this parameter is a C# 'out' parameter.

Gets whether this parameter is a C# 'params' parameter.

Gets whether this parameter is optional.

Default implementation of .

Represents a property or indexer.

Resolves the member.

Context for looking up the member. The context must specify the current assembly. A that specifies the current assembly is sufficient. Returns the resolved member, or null if the member could not be found.

Represents an unresolved type definition.

Represents an unresolved class, enum, interface, struct, delegate or VB module. For partial classes, an unresolved type definition represents only a single part.

Looks up the resolved type definition from the corresponding to this unresolved type definition.

Context for looking up the type. The context must specify the current assembly. A that specifies the current assembly is sufficient. Returns the resolved type definition. In case of an error, returns an instance. Never returns null.

This method is used to add language-specific elements like the C# UsingScope to the type resolve context.

The parent context (e.g. the parent assembly), including the parent type definition for inner classes. The parent context, modified to include language-specific elements (e.g. using scope) associated with this type definition. Use unresolvedTypeDef.CreateResolveContext(parentContext).WithTypeDefinition(typeDef) to create the context for use within the type definition.

Gets whether the type definition contains extension methods. Returns null when the type definition needs to be resolved in order to determine whether methods are extension methods.

Gets whether the partial modifier is set on this part of the type definition.

Gets whether this unresolved type definition causes the addition of a default constructor if no other constructor is present.

Default implementation of .

Type parameter of a generic class/method.

Get the type of this type parameter's owner.

SymbolKind.TypeDefinition or SymbolKind.Method

Gets the index of the type parameter in the type parameter list of the owning method/class.

Gets the list of attributes declared on this type parameter.

Gets the variance of this type parameter.

Gets the region where the type parameter is defined.

Uses the specified interning provider to intern strings and lists in this entity. This method does not test arbitrary objects to see if they implement ISupportsInterning; instead we assume that those are interned immediately when they are created (before they are added to this entity).

Replaces all occurrences of method type parameters in the given type by normalized type parameters. This allows comparing parameter types from different generic methods.

Replaces all occurrences of class type parameters in the given type by normalized type parameters. This allows comparing parameter types from different generic methods.

Replaces all occurrences of class and method type parameters in the given type by normalized type parameters. This allows comparing parameter types from different generic methods.

References a member that is an explicit interface implementation.

Resolving an ExplicitInterfaceImplementationMemberReference requires a context that provides enough information for resolving the declaring type reference and the interface member reference. Note that the interface member reference is resolved in 'context.WithCurrentTypeDefinition(declaringType.GetDefinition())' - this is done to ensure that open generics in the interface member reference resolve to the type parameters of the declaring type.

Type Reference used when the fully qualified type name is known.

Creates a new GetClassTypeReference that searches a type definition.

The full name of the type. A reference to the assembly containing this type. If this parameter is null, the GetClassTypeReference will search in all assemblies belonging to the compilation.

Creates a new GetClassTypeReference that searches a top-level type in all assemblies.

The namespace name containing the type, e.g. "System.Collections.Generic". The name of the type, e.g. "List". The number of type parameters, (e.g. 1 for List<T>).

Creates a new GetClassTypeReference that searches a top-level type in the specified assembly.

A reference to the assembly containing this type. If this parameter is null, the GetClassTypeReference will search in all assemblies belonging to the ICompilation. The namespace name containing the type, e.g. "System.Collections.Generic". The name of the type, e.g. "List". The number of type parameters, (e.g. 1 for List<T>).

Gets the assembly reference. This property returns null if the GetClassTypeReference is searching in all assemblies of the compilation.

Gets the full name of the type this reference is searching for.

Provides helper methods for implementing GetMembers() on IType-implementations. Note: GetMembersHelper will recursively call back into IType.GetMembers(), but only with both GetMemberOptions.IgnoreInheritedMembers and GetMemberOptions.ReturnMemberDefinitions set, and only the 'simple' overloads (not taking type arguments). Ensure that your IType implementation does not use the GetMembersHelper if both flags are set, otherwise you'll get a StackOverflowException!

Cache for KnownTypeReferences.

A merged namespace.

Creates a new merged root namespace.

The main compilation. The individual namespaces being merged. The extern alias for this namespace.

Creates a new merged child namespace.

The parent merged namespace. The individual namespaces being merged.

Resolve context represents the minimal mscorlib required for evaluating constants. This contains all known types () and no other types.

Type reference used to reference nested types.

Creates a new NestedTypeReference.

Reference to the declaring type. Name of the nested class Number of type parameters on the inner class (without type parameters on baseTypeRef) must be exactly the (unbound) declaring type, not a derived type, not a parameterized type. NestedTypeReference thus always resolves to a type definition, never to (partially) parameterized types.

Simple compilation implementation.

A simple constant value that is independent of the resolve context.

Simple interning provider.

Represents a specialized IEvent (event after type substitution).

Represents a SpecializedMember (a member on which type substitution has been performed).

Performs a substitution. This method may only be called by constructors in derived classes.

Gets the substitution belonging to this specialized member.

Represents a specialized IField (field after type substitution).

Represents a specialized IMethod (e.g. after type substitution).

Represents a specialized IProperty (property after type substitution).

Creates a type parameter reference. For common type parameter references, this method may return a shared instance.

An unknown type where (part) of the name is known.

Creates a new unknown type.

Namespace name, if known. Can be null if unknown. Name of the type, must not be null. Type parameter count, zero if unknown.

Creates a new unknown type.

Full name of the unknown type.

Special type definition for 'void'.

Provides helper methods for inheritance.

Gets the base member that has the same signature.

Gets all base members that have the same signature.

List of base members with the same signature. The member from the derived-most base class is returned first.

Finds the member declared in 'derivedType' that has the same signature (could override) 'baseMember'.

Represents the intersection of several types.

Represents a single file that was parsed.

Gets the top-level type defined at the specified location. Returns null if no type is defined at that location.

Gets the type (potentially a nested type) defined at the specified location. Returns null if no type is defined at that location.

Gets the member defined at the specified location. Returns null if no member is defined at that location.

Returns the full path of the file.

Gets the time when the file was last written.

Gets all top-level type definitions.

Gets all assembly attributes that are defined in this file.

Gets all module attributes that are defined in this file.

Gets the parser errors.

Represents an assembly consisting of source code (parsed files).

Gets a parsed file by its file name.

Creates a new that allows resolving within this project.

This method does not support s. When dealing with a solution containing multiple projects, consider using instead.

Creates a new that allows resolving within this project.

The parent solution snapshot to use for the compilation. This method is intended to be called by ISolutionSnapshot implementations. Other code should call instead. This method always creates a new compilation, even if the solution snapshot already contains one for this project.

Changes the assembly name of this project content.

Changes the project file name of this project content.

Changes the path to the assembly location (the output path where the project compiles to).

Add assembly references to this project content.

Add assembly references to this project content.

Removes assembly references from this project content.

Removes assembly references from this project content.

Adds the specified files to the project content. If a file with the same name already exists, updated the existing file.

You can create an unresolved file by calling ToTypeSystem() on a syntax tree.

Adds the specified files to the project content. If a file with the same name already exists, this method updates the existing file.

You can create an unresolved file by calling ToTypeSystem() on a syntax tree.

Removes the files with the specified names.

Removes the files with the specified names.

Removes types and attributes from oldFile from the project, and adds those from newFile.

Removes types and attributes from oldFiles from the project, and adds those from newFiles.

Sets the compiler settings object. The concrete type of the settings object depends on the programming language used to implement this project. Using the incorrect type of settings object results in an .

Gets the path to the project file (e.g. .csproj).

Gets the list of all files in the project content.

Gets the referenced assemblies.

Gets the compiler settings object. The concrete type of the settings object depends on the programming language used to implement this project.

No options specified - this is the default. Members will be specialized, and inherited members will be included.

Do not specialize the returned members - directly return the definitions.

Do not list inherited members - only list members defined directly on this type.

Represents the variance of a type parameter.

The type parameter is not variant.

The type parameter is covariant (used in output position).

The type parameter is contravariant (used in input position).

Represents some well-known types.

Not one of the known types.

object (System.Object)

System.DBNull

bool (System.Boolean)

char (System.Char)

sbyte (System.SByte)

byte (System.Byte)

short (System.Int16)

ushort (System.UInt16)

int (System.Int32)

uint (System.UInt32)

long (System.Int64)

ulong (System.UInt64)

float (System.Single)

double (System.Double)

decimal (System.Decimal)

System.DateTime

string (System.String)

void (System.Void)

System.Type

System.Array

System.Attribute

System.ValueType

System.Enum

System.Delegate

System.MulticastDelegate

System.Exception

System.IntPtr

System.UIntPtr

System.Collections.IEnumerable

System.Collections.IEnumerator

System.Collections.Generic.IEnumerable{T}

System.Collections.Generic.IEnumerator{T}

System.Collections.Generic.ICollection

System.Collections.Generic.ICollection{T}

System.Collections.Generic.IList

System.Collections.Generic.IList{T}

System.Collections.Generic.IReadOnlyCollection{T}

System.Collections.Generic.IReadOnlyList{T}

System.Threading.Tasks.Task

System.Threading.Tasks.Task{T}

System.Nullable{T}

System.IDisposable

System.Runtime.CompilerServices.INotifyCompletion

System.Runtime.CompilerServices.ICriticalNotifyCompletion

Contains well-known type references.

Gets the known type reference for the specified type code. Returns null for KnownTypeCode.None.

Gets a type reference pointing to the object type.

Gets a type reference pointing to the System.DBNull type.

Gets a type reference pointing to the bool type.

Gets a type reference pointing to the char type.

Gets a type reference pointing to the sbyte type.

Gets a type reference pointing to the byte type.

Gets a type reference pointing to the short type.

Gets a type reference pointing to the ushort type.

Gets a type reference pointing to the int type.

Gets a type reference pointing to the uint type.

Gets a type reference pointing to the long type.

Gets a type reference pointing to the ulong type.

Gets a type reference pointing to the float type.

Gets a type reference pointing to the double type.

Gets a type reference pointing to the decimal type.

Gets a type reference pointing to the System.DateTime type.

Gets a type reference pointing to the string type.

Gets a type reference pointing to the void type.

Gets a type reference pointing to the System.Type type.

Gets a type reference pointing to the System.Array type.

Gets a type reference pointing to the System.Attribute type.

Gets a type reference pointing to the System.ValueType type.

Gets a type reference pointing to the System.Enum type.

Gets a type reference pointing to the System.Delegate type.

Gets a type reference pointing to the System.MulticastDelegate type.

Gets a type reference pointing to the System.Exception type.

Gets a type reference pointing to the System.IntPtr type.

Gets a type reference pointing to the System.UIntPtr type.

Gets a type reference pointing to the System.Collections.IEnumerable type.

Gets a type reference pointing to the System.Collections.IEnumerator type.

Gets a type reference pointing to the System.Collections.Generic.IEnumerable{T} type.

Gets a type reference pointing to the System.Collections.Generic.IEnumerator{T} type.

Gets a type reference pointing to the System.Collections.ICollection type.

Gets a type reference pointing to the System.Collections.Generic.ICollection{T} type.

Gets a type reference pointing to the System.Collections.IList type.

Gets a type reference pointing to the System.Collections.Generic.IList{T} type.

Gets a type reference pointing to the System.Collections.Generic.IReadOnlyCollection{T} type.

Gets a type reference pointing to the System.Collections.Generic.IReadOnlyList{T} type.

Gets a type reference pointing to the System.Threading.Tasks.Task type.

Gets a type reference pointing to the System.Threading.Tasks.Task{T} type.

Gets a type reference pointing to the System.Nullable{T} type.

Gets a type reference pointing to the System.IDisposable type.

Gets a type reference pointing to the System.Runtime.CompilerServices.INotifyCompletion type.

Gets a type reference pointing to the System.Runtime.CompilerServices.ICriticalNotifyCompletion type.

Gets the C# primitive type name from the known type code. Returns null if there is no primitive name for the specified type.

Static helper methods for working with nullable types.

Gets whether the specified type is a nullable type.

Returns the element type, if is a nullable type. Otherwise, returns the type itself.

Creates a nullable type.

Creates a nullable type reference.

ParameterizedType represents an instance of a generic type. Example: List<string>

When getting the members, this type modifies the lists so that type parameters in the signatures of the members are replaced with the type arguments.

Fast internal version of the constructor. (no safety checks) Keeps the array that was passed and assumes it won't be modified.

Same as 'parameterizedType.TypeArguments[index]', but is a bit more efficient (doesn't require the read-only wrapper).

Gets the definition of the generic type. For ParameterizedType, this method never returns null.

Gets a type visitor that performs the substitution of class type parameters with the type arguments of this parameterized type.

Gets a type visitor that performs the substitution of class type parameters with the type arguments of this parameterized type, and also substitutes method type parameters with the specified method type arguments.

ParameterizedTypeReference is a reference to generic class that specifies the type parameters. Example: List<string>

Compares parameter lists by comparing the types of all parameters.

'ref int' and 'out int' are considered to be equal. 'object' and 'dynamic' are also equal. For generic methods, "Method{T}(T a)" and "Method{S}(S b)" are considered equal. However, "Method(T a)" and "Method(S b)" are not considered equal when the type parameters T and S belong to classes.

Replaces all occurrences of method type parameters in the given type by normalized type parameters. This allows comparing parameter types from different generic methods.

Compares member signatures.

This comparer checks for equal short name, equal type parameter count, and equal parameter types (using ParameterListComparer).

Gets a signature comparer that uses an ordinal comparison for the member name.

References another project content in the same solution. Using the class requires that you

Creates a new reference to the specified project (must be part of the same solution).

Full path to the file name. Must be identical to of the target project; do not use a relative path.

Represents an error while parsing a reflection name.

Default ITypeResolveContext implementation.

Holds the name of a top-level type. This struct cannot refer to nested classes.

.

Language-specific type that is not part of NRefactory.TypeSystem itself.

A or that is a class.

A or that is an interface.

A or that is a struct.

A or that is a delegate.

System.Delegate itself is TypeKind.Class

A that is an enum.

System.Enum itself is TypeKind.Class

A that is a module (VB).

The System.Void type.

The type of the null literal.

Type representing the C# 'dynamic' type.

Represents missing type arguments in partially parameterized types.

The type is a type parameter.

An array type

A pointer type

A managed reference type

An anonymous type

Intersection of several types

Static helper methods for reflection names.

Retrieves the specified type in this compilation. Returns if the type cannot be found in this compilation.

This method cannot be used with open types; all type parameters will be substituted with .

Creates a reference to the specified type.

The type to be converted. Returns the type reference. If the type is open (contains type parameters '`0' or '``0'), an with the appropriate CurrentTypeDefinition/CurrentMember is required to resolve the type reference. For closed types, the root type resolve context for the compilation is sufficient.

Removes the ` with type parameter count from the reflection name.

Do not use this method with the full name of inner classes.

Removes the ` with type parameter count from the reflection name.

Do not use this method with the full name of inner classes.

Retrieves a built-in type using the specified type code.

Creates a reference to the specified type.

The type to be converted. Returns the type reference.

Gets the type code for the specified type, or TypeCode.Empty if none of the other type codes match.

Parses a reflection name into a type reference.

The reflection name of the type. A type reference that represents the reflection name. The syntax of the reflection type name is invalid If the type is open (contains type parameters '`0' or '``0'), an with the appropriate CurrentTypeDefinition/CurrentMember is required to resolve the reference to the ITypeParameter. For looking up closed, assembly qualified type names, the root type resolve context for the compilation is sufficient. When looking up a type name that isn't assembly qualified, the type reference will look in first, and if the type is not found there, it will look in all other assemblies of the compilation.

A reflection class used to represent null.

A reflection class used to represent dynamic.

A reflection class used to represent an unbound type argument.

Contains static implementations of special types.

Gets the type representing resolve errors.

The null type is used as type of the null literal. It is a reference type without any members; and it is a subtype of all reference types.

Type representing the C# 'dynamic' type.

A type used for unbound type arguments in partially parameterized types.

A binary reader that can read the output of BinaryWriterWith7BitEncodedInts.

A binary writer that encodes all integers as 7-bit-encoded-ints.

Holds 16 boolean values.

This class is used to prevent stack overflows by representing a 'busy' flag that prevents reentrance when another call is running. However, using a simple 'bool busy' is not thread-safe, so we use a thread-static BusyManager.

Allows caching values for a specific compilation. A CacheManager consists of a for shared instances (shared among all threads working with that resolve context).

This class is thread-safe

Invokes an action when it is disposed.

This class ensures the callback is invoked at most once, even when Dispose is called on multiple threads.

Static helper method for converting between primitive types.

Performs a conversion between primitive types. Unfortunately we cannot use Convert.ChangeType because it has different semantics (e.g. rounding behavior for floats, overflow, etc.), so we write down every possible primitive C# cast and let the compiler figure out the exact semantics. And we have to do everything twice, once in a checked-block, once in an unchecked-block.

Overflow checking is enabled and an overflow occurred. The cast is invalid, e.g. casting a boolean to an integer.

Contains extension methods for use within NRefactory.

Emit 'scan instance.Field'. Stack transition: ... => ...

Stack transition: ..., value => ...

Emit 'write instance.Field'. Stack transition: ... => ...

Writes a primitive value of the specified type. Stack transition: ..., writer, value => ...

Stack transition: ..., value => ...

Reads a primitive value of the specified type. Stack transition: ... => ..., value

Stack transition: ..., field-ref => ...

Gets/Sets the serialization binder that is being used. The default value is null, which will cause the FastSerializer to use the full assembly and type names.

Can be used to set several 'fixed' instances. When serializing, such instances will not be included; and any references to a fixed instance will be stored as the index in this array. When deserializing, the same (or equivalent) instances must be specified, and the deserializer will use them in place of the fixed instances.

Marks an instance for future scanning.

Specifies the version of the class. The will refuse to deserialize an instance that was stored by a different version of the class than the current one.

GraphViz graph.

edge stroke color

use edge to affect node ranking

point size of label

point size of label

minimum height in inches

space around label

node shape

An immutable stack. Using 'foreach' on the stack will return the items from top to bottom (in the order they would be popped).

Gets the empty stack instance.

Pushes an item on the stack. This does not modify the stack itself, but returns a new one with the value pushed.

Gets the item on the top of the stack.

The stack is empty.

Gets the item on the top of the stack. Returns default(T) if the stack is empty.

Gets the stack with the top item removed.

The stack is empty.

Gets an enumerator that iterates through the stack top-to-bottom.

Gets if this stack is empty.

Atomically performs the following operation: - If target is null: stores newValue in target and returns newValue. - If target is not null: returns target.

A dictionary that allows multiple pairs with the same key.

Removes all entries with the specified key.

Returns true if at least one entry was removed.

Returns the number of different keys.

Platform-specific code.

Static helper methods for traversing trees.

Converts a tree data structure into a flat list by traversing it in pre-order.

The root element of the tree. The function that gets the children of an element. Iterator that enumerates the tree structure in pre-order.

Converts a tree data structure into a flat list by traversing it in pre-order.

The root elements of the forest. The function that gets the children of an element. Iterator that enumerates the tree structure in pre-order.

Converts a tree data structure into a flat list by traversing it in post-order.

The root element of the tree. The function that gets the children of an element. Iterator that enumerates the tree structure in post-order.

Converts a tree data structure into a flat list by traversing it in post-order.

The root elements of the forest. The function that gets the children of an element. Iterator that enumerates the tree structure in post-order.

Enum that describes the type of an error.

Descibes an error during parsing.

Initializes a new instance of the class.

The error type. The description of the error. The region of the error.

Initializes a new instance of the class.

The error type. The description of the error. The location of the error.

Initializes a new instance of the class.

The error type. The description of the error. The line of the error. The column of the error.

Initializes a new instance of the class.

The error type. The description of the error.

The type of the error.

The error description.

The region of the error.

Provides intellisense information for a collection of parametrized members.

Returns the markup to use to represent the specified method overload in the parameter information window.

Returns the markup for the description to use to represent the specified method overload in the parameter information window.

Returns the text to use to represent the specified parameter

Gets the name of the parameter.

Returns the number of parameters of the specified method

Used for the params lists. (for example "params" in c#).

Gets the overload count.

Gets the start offset of the parameter expression node.

Provides ID strings for entities. (C# 4.0 spec, §A.3.1) ID strings are used to identify members in XML documentation files.

Gets the ID string (C# 4.0 spec, §A.3.1) for the specified entity.

Parse the ID string into a member reference.

The ID string representing the member (with "M:", "F:", "P:" or "E:" prefix). A member reference that represents the ID string. The syntax of the ID string is invalid The member reference will look in first, and if the member is not found there, it will look in all other assemblies of the compilation.

Parse the ID string type name into a type reference.

The ID string representing the type (the "T:" prefix is optional). A type reference that represents the ID string. The syntax of the ID string is invalid The type reference will look in first, and if the type is not found there, it will look in all other assemblies of the compilation. If the type is open (contains type parameters '`0' or '``0'), an with the appropriate CurrentTypeDefinition/CurrentMember is required to resolve the reference to the ITypeParameter.

Finds the entity in the given type resolve context.

ID string of the entity. Type resolve context Returns the entity, or null if it is not found. The syntax of the ID string is invalid

Composite format string parser.

Implements a complete parser for valid strings as well as error reporting and best-effort parsing for invalid strings.

Parse the specified format string.

The format string.

Composite format string parser.

Implements a complete parser for valid strings as well as error reporting and best-effort parsing for invalid strings.

Composite format string parser.

Implements a complete parser for valid strings as well as error reporting and best-effort parsing for invalid strings.

Gets the EditorBrowsableState of an entity.

The editor browsable state. Entity.

Determines if an entity should be shown in the code completion window. This is the same as: GetEditorBrowsableState (entity) != System.ComponentModel.EditorBrowsableState.Never

true if the entity should be shown; otherwise, false. The entity.

The issue marker is used to set how an issue should be marked inside the text editor.

The issue is not shown inside the text editor. (But in the task bar)

The region is marked as underline in the severity color.

The region is marked as dotted line in the severity color.

The text is grayed out.

The severity influences how the task bar reacts on found issues.

None means that the task bar doesn't show the issue.

Errors are shown in red and that the task bar is in error state if 1 error is found.

Warnings are shown in yellow and set the task bar to warning state (if no error is found).

Suggestions are shown in green and doesn't influence the task bar state

Hints are shown in blue and doesn't influence the task bar state

The symbol collector collects related symbols that form a group of symbols that should be renamed when a name of one symbol changes. For example if a type definition name should be changed the constructors and destructor names should change as well.

Gets the related symbols.

The related symbols. The type graph. The symbol to search

Gets or sets a value indicating whether this should include overloads.

true if overloads should be included; otherwise, false.

Specifies whether to include internal members. The default is false.

Gets/Sets the cancellation token used by the assembly loader.

Gets/Sets the documentation provider that is used to retrieve the XML documentation for all members.

Gets/Sets the interning provider.

Line Feed, U+000A

Carriage Return, U+000D

Next Line, U+0085

Vertical Tab, U+000B

Form Feed, U+000C

Line Separator, U+2028

Paragraph Separator, U+2029

Defines unicode new lines according to Unicode Technical Report #13 http://www.unicode.org/standard/reports/tr13/tr13-5.html

Carriage Return, U+000D

Line Feed, U+000A

Next Line, U+0085

Vertical Tab, U+000B

Form Feed, U+000C

Line Separator, U+2028

Paragraph Separator, U+2029

Determines if a char is a new line delimiter.

0 == no new line, otherwise it returns either 1 or 2 depending of the length of the delimiter. The current character. A callback getting the next character (may be null).

Determines if a char is a new line delimiter.

0 == no new line, otherwise it returns either 1 or 2 depending of the length of the delimiter. The current character. The next character (if != LF then length will always be 0 or 1).

Determines if a char is a new line delimiter.

0 == no new line, otherwise it returns either 1 or 2 depending of the length of the delimiter. The current character. The length of the delimiter The type of the delimiter A callback getting the next character (may be null).

Determines if a char is a new line delimiter.

0 == no new line, otherwise it returns either 1 or 2 depending of the length of the delimiter. The current character. The length of the delimiter The type of the delimiter The next character (if != LF then length will always be 0 or 1).

Gets the new line type of a given char/next char.

0 == no new line, otherwise it returns either 1 or 2 depending of the length of the delimiter. The current character. A callback getting the next character (may be null).

Gets the new line type of a given char/next char.

0 == no new line, otherwise it returns either 1 or 2 depending of the length of the delimiter. The current character. The next character (if != LF then length will always be 0 or 1).

Determines if a char is a new line delimiter. Note that the only 2 char wide new line is CR LF and both chars are new line chars on their own. For most cases GetDelimiterLength is the better choice.

Gets the new line as a string.

The framework lookup provides a fast lookup where an unknow type or extension method may be defined in.

This method tries to get a matching extension method.

The extension method lookups. The resolve result.

Tries to get a type out of an unknow identifier result.

The assemblies the type may be defined (if any). The resolve result. Type parameter count. If set to true this resolve result may be inside an attribute.

Tries to get a type out of an unknow member resolve result. (In case of fully qualified names)

The assemblies the type may be defined (if any). The resolve result. Type parameter count. If set to true this resolve result may be inside an attribute.

This method returns a new framework builder to build a new framework lookup data file.

The file name of the data file.

Loads a framework lookup object from a file. May return null, if the file wasn't found or has a version mismatch.

File name.

Retrieves a hash code for the specified string that is stable across .NET upgrades. Use this method instead of the normal string.GetHashCode if the hash code is persisted to disk.

The assembly lookup determines where a type might be defined. It contains the assembly & the namespace.

Initializes a new instance of the struct.

The package name. The full name of the assembly. The namespace the type is in.

The namespace the requested type is in.

Gets the full name af the assembly.

Gets the package the assembly is in.

Add a type to the framework lookup.

The package the assembly of the type is defined (can be null). The full assembly name the type is defined (needs to be != null). The type definition (needs to be != null).

A list that can be compared to other ComparableLists for equality. Can not be used to store null values.

Matches any node.

Does not match null nodes.

The text paste handler can do formattings to a text that is about to be pasted into the text document.

Formats plain text that is inserted at a specified offset.

The text that will get inserted at that position. The offset where the text will be inserted. The text to be inserted. Additional data in case the text was copied from a Mono.TextEditor.

Gets the copy data for a specific segment inside the document. This can contain additional information.

The text segment that is about to be copied.