TypeRefBase Class

Initializes a new instance of the TypeRefBase class

Initializes a new instance of the TypeRefBase class

Initializes a new instance of the TypeRefBase class

Initializes a new instance of the TypeRefBase class

Initializes a new instance of the TypeRefBase class

Initializes a new instance of the TypeRefBase class

Initializes a new instance of the TypeRefBase class

Initializes a new instance of the TypeRefBase class

Initializes a new instance of the TypeRefBase class

Initializes a new instance of the TypeRefBase class

Initializes a new instance of the TypeRefBase class

This property is just to make debugging easier.

Annotations (comments, attributes, directives, messages) associated with the current code object.

The array ranks of the type reference (if any).

The descriptive category of the SymbolicRef.

The column number associated with the CodeObject (if any, 0 if none).

The comment for the code object (if any).

The documentation comment for the code object (if any).

True if the referenced type should display as a type name instead of a keyword if it's a primitive type.

The End-Of-Line comment for the code object (if any).

True if the code object has any annotations.

True if the type reference has any array ranks.

True if the code object has any attributes.

True if the code object has any comments of any kind.

True if the code object has any compiler directive annotations.

True if the code object has any documentation comments.

True if the code object has any EOL comments.

True if the code object has any EOL or Postfix annotations.

True if the code object has any error messages.

True if the code object has any annotations on separate lines.

True if the code object has any Infix comments.

True if the code object has any generated messages.

Determines if the code object has no indentation.

True if the code object has any regular (non-doc) preceding (non-EOL, non-Infix, non-Postfix) comments.

True if the expression is surrounded by parens.

True if the expression should have parens by default.

True if the code object has any postfix annotations.

Determines if the code object has a terminator character.

True if there are any type arguments.

Any hidden reference to another CodeObject.

The infix comment for the code object (if any).

True if the type reference is an array.

True if the referenced type is a built-in type (has a keyword). The built-in types are: object, void, sbyte, byte, short, ushort, int, uint, long, ulong, char, bool, string, float, double, decimal

True if the expression is const.

True if the referenced type is a delegate type.

Returns true if the TypeRefBase is a DocCodeRefBase reference to a code object, otherwise false.

True if the closing paren or bracket is on a new line.

Determines if the code object appears as the first item on a line.

True if the code object defaults to starting on a new line.

True if the referenced type is a fixed buffer type.

Determines if the code object is generated.

Determines if the 'grouping' (has parens or braces) status has been set.

True if the referenced type is an interface.

True if the referenced type or method has internal access.

Determines if the newline count has been set on the code object.

True if the referenced type is a nullable type.

True if the type reference is a pointer.

True if the expression evaluates to a delegate, unresolved, or dynamic type or a TypeParameterRef.

True if the type is Primitive. The Primitive Types are: sbyte, byte, short, ushort, int, uint, long, ulong, IntPtr, UIntPtr, char, bool, float, double. The following are NOT primitive types: object, void, string, decimal

True if the referenced type or method has private access.

True if the referenced type or method has protected access.

True if the referenced type or method has public access.

True if the CodeObject is renderable.

Determines if the code object only requires a single line for display.

True if the code object only requires a single line for display by default.

True if the referenced type or method is static.

The line number associated with the CodeObject (if any, 0 if none).

The name of the SymbolicRef.

The number of newlines preceding the object (0 to N).

The parent CodeObject.

The number of pointer dereferences.

The postfix comment for the code object (if any).

The code object to which the SymbolicRef refers.

The number of type arguments.

The type argument Expressions of the reference (if any).

Accept the specified visitor object for the current code object and it's children.

Accept the specified visitor object for all regular (non-EOL, non-Infix, non-Postfix) annotations (comments, attributes, compiler directives).

Accept the specified visitor object for all specified Infix or Postfix annotations (comments, compiler directives).

Accept the specified visitor object for all EOL comments.

Accept the specified visitor object for all Infix comments.

Accept the specified visitor object for all Infix EOL comments.

Format an array rank as a string.

Determine if the specified comment should be associated with the current code object during parsing.

Render the entire code object as a string, using LFs for newlines.

Convert the code object to text with a trailing newline, and using CR/LF pairs for newlines (file format).

Convert the code object to text using the specified flags and format (file or string).

Render all regular (non-EOL, non-Infix, non-Postfix, non-Message) annotations (comments, attributes, compiler directives).

Render all specified Infix or Postfix annotations (comments, compiler directives).

Render array rank brackets (if any) as text.

Render type constraints as text.

Render type constraints as text.

Render all EOL comments.

Render a generic member as text.

Render a generic member as text.

Render all Infix comments with the specified mask.

Render all Infix EOL comments.

Render all regular annotations on the current object, or the left most binary operator.

Determine the length of the code object if converted to a string using the specified flags.

Render pointers (if any) as text.

Render a Type as text.

Render type arguments (if any) as text.

Render a TypeReference as text.

Attach an Annotation (Comment, DocComment, Attribute, CompilerDirective, or Message) to the CodeObject.

Attach an Annotation to the CodeObject at the specified position.

Create a comment object and attach it to the code object.

Create an EOL comment object and attach it to the code object.

Create a message and attach it to the code object.

Calculate metrics for this code object and its children.

Check for alignment of any EOL comments.

Deep-clone the code object.

Clone a field of a code object, including setting the parent.

Clone a field of a code object, including setting the parent.

Convert all OpenTypeParameterRef type arguments to TypeParameterRefs.

Copy formatting from another code object.

Create the list of child Annotations, or return the existing one.

Create the child list of array ranks, or return the existing one.

Create a reference to the CodeObject.

Create the child list of type argument Expressions, or return the existing one.

Default format the code object.

Default format the specified child field code object.

Determine a default of 1 or 2 newlines when adding items to a Block.

Dispose the CodeObject.

Determines whether the specified object is equal to the current object.

Evaluate the type of the Expression.

Evaluate the types of any type arguments of the TypeRef by searching for matching type arguments in the specified parent code object tree.

Evaluate the Expression to a type or namespace.

Allows an object to try to free resources and perform other cleanup operations before it is reclaimed by garbage collection.

Find the parent object of the specified type.

Find the parent method (or anonymous method or lambda) of the current code object.

Find the parent method (or anonymous method or lambda) or type of the current code object.

Find a type argument for the specified type parameter.

Find a type argument for the specified type parameter in the type arguments of the type.

Get the expression on the left of the left-most Dot operator.

Format an expression assigned as an argument to another code object (turns off any parentheses).

Get an enumerator for all children objects of type T in the CodeObject and in any child CodeObjects (recursively).

Returns the first attribute expression (Call or ConstructorRef) with the specified name on the CodeObject.

Get the comment that satisfies the specified predicate.

Get the value of any represented constant. For enums, an EnumConstant object will be returned, which has both the Enum type and a constant value of its underlying type.

Get the declaring type of the referenced object (returns null if none).

Get the delegate parameters if the expression evaluates to a delegate type.

Get the type (or null if none) of the delegate parameter with the specified index.

Get the delegate return type if the expression evaluates to a delegate type.

Get a short text description of the CodeObject. This is generally the shortest text representation that uniquely identifies objects, even if they have the same name, for example: type or return type, name, type parameters, parameters.

Returns the DocSummary documentation comment, or null if none exists.

Get the element type of the type reference (if it's an array or pointer, otherwise null).

Get the full name of the object, including the namespace name.

Serves as the default hash function.

Get the indent level of this object.

Get the current indent in spaces.

Determine the type of an inferred ('var') type.

Calculate a hash code for the referenced object which is the same for all references where IsSameRef() is true.

Get the Namespace for this CodeObject.

Get the actual type reference (ITypeDecl or Type), retrieving them from any constant values if necessary.

Gets the Type of the current instance.

Get the variance state of the type argument with the specified index;

Get any modifiers from the specified Type.

Get any modifiers from the specified TypeDefinition.

Get a TypeRef for the type with the specified full name, with caching (generally used for System types).

Get the actual type, excluding any constant values.

Get the type of the worst attached message.

Returns true if the attribute with the specified name exists on the object, otherwise false.

Check if an implicit conversion will take place between the expression and its parent code object (Operator or VariableDecl). Conversions to type 'object' are not included, since there is no actual data conversion. The 'from' and 'to' types are returned whether an implicit conversion is available or not. Any applicable user-defined conversion method is returned.

Recursively scan the type arguments to determine if we have a TypeParameterRef anywhere.

Returns true if the code object is an UnresolvedRef or has any UnresolvedRef children.

Determine if an implicit identity conversion exists to the specified type.

Determine if an implicit reference conversion exists to the specified type.

Returns true if the specified child object is indented from the parent.

Returns true if the specified child object is prefixed to the current object.

Determine if the type reference is an enumerable type (is compatible with an array). Includes:

Determine if the reference is implicitly convertible *from* the specified reference.

Determine if the TypeRefBase is implicitly convertible to the specified TypeRefBase.

Determine if the specified TypeRefBase refers to the same generic type, regardless of actual type arguments.

Determine if the current reference refers to the same code object as the specified reference.

Make an array reference from the current type reference.

Make a generic type reference from the current type reference.

Creates a shallow copy of the current Object.

Move all (regular or EOL) comments from the specified token to the current code object, converting any EOL comments to regular comments (which will be rendered inline if necessary).

Move any annotations from the specified location to the specified destination location.

Move any non-EOL comments from the specified token to the current code object.

Move any non-EOL comments from the specified token to the current code object.

Move any non-EOL comments from the specified token to the current code object as Post comments.

Move any comments from the specified Token to the left-most sub-expression.

Move any EOL or Postfix annotations from the specified code object to the current code object.

Move any EOL comment from the specified code object to the current code object.

Move any EOL comment from the specified token to the current code object.

Move any EOL comment from the specified token to the current code object.

Move any EOL comment from the specified token to the current code object as an Infix EOL comment.

Move formatting from the specified code object to the current object.

Move formatting from the specified token to the current object.

Move any prefix annotations on the specified code object to the current code object as the specified type of annotation.

Propagate the listed annotation to the parent CodeUnit and above.

Remove the listed annotation from the parent CodeUnit and above.

Determine if the current type is the same as or occurs in the (potentially nested) type arguments of the specified type.

Parse annotations - specifically, compiler directives around things such as TypeParameters or ParameterDecls.

Parse any comments, attributes, compiler directives.

Parse multiple array ranks.

Parse the specified expected token, attaching a parse error to the current object if it doesn't exist.

Parse a list of type arguments.

Parse annotations from the Unused list.

Peek ahead at the input tokens to determine if they look like valid array rank specifiers.

Peek ahead at the input tokens to determine if they look like a valid type.

Peek ahead at the input tokens to determine if they look like a valid type argument list.

Remove all annotations of the specified type from this object.

Remove all annotations from this object where the specified predicate is true.

Remove all messages from this object, or optionally only from the specified source.

Remove the attribute expression with the specified name.

Replace all occurrences of one type reference with another, including in (potentially nested) type arguments.

Resolve all child symbolic references.

Resolve all child symbolic references, using the specified ResolveCategory and ResolveFlags.

Resolve any attached attributes.

Resolve any references in attached documentation comments.

Resolve child code objects that match the specified name are valid goto targets, moving up the tree until a complete match is found.

Resolve indexers.

Resolve any LocalDeclExpr in the Expression or its children that match the specified name.

Resolve child code objects that match the specified name.

Resolve child code objects that match the specified name, moving up the tree until a complete match is found.

Similar to ResolveRefUp(String, Resolver), but skips trying to resolve the symbol in the body or parameters of a method (used for resolving parameter types).

Set a field of a code object, including setting the parent, and optional formatting.

Set a ChildList collection field of a code object, including setting the parent.

Set a field of a code object, including setting the parent, and optional formatting.

Set the line and column numbers to those in the specified CodeObject.

Set the line and column numbers to those in the specified token.

Special method to set the newline count without setting the NewLinesSet flag.

Set the starting line and column numbers to those in the specified token (used by some code objects with prefixes such as modifiers).

Get the expression on the right of the right-most Lookup or Dot operator (bypass any '::' and '.' prefixes).

Render the type of the code object and its description as a string.

Recursively update the dictionary of names in the specified Block by either adding or removing (as specified by the 2nd parameter) all appropriate nested INamedCodeObjects expressions in the current CodeObject tree (specifically implemented for LocalDeclExpr expression objects).

Update the line and column numbers according to the current positions in the CodeWriter, if the UpdateLineCol flag is set.

Implicit conversion of a MethodBase to a TypeRefBase (actually, a MethodRef or ConstructorRef).

Implicit conversion of a Type to a TypeRefBase (actually, a TypeRef).

Implicit conversion of a MethodDeclBase to a TypeRefBase (actually, a MethodRef or ConstructorRef).

Implicit conversion of a TypeDecl to a TypeRefBase (actually, a TypeRef).

Implicit conversion of a TypeParameter to a TypeRefBase (actually, a TypeParameterRef).

Any Annotations (Comments, DocComments, Attributes, or Messages) associated with the CodeObject (null if none).

Optional array ranks (for array types only).

The starting column number associated with the CodeObject if parsed from or written to text form.

Formatting flags - for line feeds, braces, etc.

The starting line number associated with the CodeObject if parsed from or written to text form.

The parent CodeObject.

Optional type arguments (for generic types only).

Optional flags, including pointer count, const state, formatting.

The alternate token used to parse the end of type arguments inside documentation comments.

The alternate token used to parse the start of type arguments inside documentation comments.

The token used to parse the end of type arguments.

The token used to parse the start of type arguments.

The token used to parse the end of array ranks.

The token used to parse the start of array ranks.

The token used to parse nullable types.

The token used to parse pointer types.

A map of built-in type names to keywords (the "System" namespace prefix is NOT included on the names).