Adds one Expression to another.
Represents a special type of method used to add to an event.
Takes the address of a fixed variable in an unsafe context.
Performs a conditional (logical) 'and' of two boolean Expressions.
Represents an un-named method that can be assigned to a delegate.
Declares a "nameless" class. Declared only implicitly by NewObject.
Represents a reference to an anonymous type (a type that is determined at compile-time).
Manages all assemblies loaded into an AppDomain.
Creates a variable list of arguments (RuntimeArgumentHandle) for use by ArgIterator. This is an undocumented C# operator.
Represents the declaration of an (undocumented) '__arglist' parameter.
Converts an Expression to the specified type, returning null if the conversion can't be done.
Represents a project reference to an external assembly.
Represents metadata associated with a CodeObject.
Static helper methods and extension methods for the AttributeTarget enum.
Indicates that an expression should be executed asynchronously.
Represents a call to a constructor in the base class (constructor initializer).
Represents a reference to the base class of the current object instance.
Performs a boolean AND operation on two Expressions.
Performs a boolean OR operation on two Expressions.
Performs a boolean XOR operation on two Expressions.
Represents a stand-alone block of code restricted to a local scope (surrounded by braces).
Represents a user-overloaded 'true' or 'false' operator.
Causes execution of the active loop or switch/case block to terminate.
Represents a call to a Method or a Delegate, including any arguments.
Used as a child of a Switch. Includes a constant expression plus a body (a statement or block).
The Cast operator casts an Expression to the specified Type.
Explicitly turns ON overflow checking (exceptions) for an Expression.
Contains a body of code for which overflow checking is explicitly turned on.
Represents a collection of child CodeObjects of a particular type. Sets the Parent reference of each child object added to the collection.
Extension methods for ChildList - extension methods are used in these cases so that the collection itself can be checked for being null inside the call.
Constrains the type that a TypeParameter can represent to a reference type.
Declares a class, which includes a name plus a body, along with various optional modifiers.
The common base class of all code objects.
Represents user comments, and may either be independent or associated with another CodeObject.
Performs a one's complement (toggles all bits) on an Expression.
Represents a project reference to a COM object.
Represents a conditional if/then/else (ternary) expression.
Represents one or more contraints on a type parameter.
Causes execution to jump back to the top of the active loop.
Represents a user-defined conversion operator.
Used as a child of a Switch. Includes a body (a statement or block).
Returns the default value for the specified type.
Provides for the definition of a "pre-processor" symbol - may only appear at the very top of a CodeUnit (file)!
Declares a type that represents a reference to a method.
Represents a named Block of code used to destruct the instance of a class. It has no modifiers or parameters, can't be inherited or overloaded, and can't be called directly. Only classes can have them, and they can only have one.
Represents a reference to a pre-processor directive symbol.
Divides one Expression by another.
Represents a section of bold text in a documentation comment.
Represents a fragment of code in a documentation comment.
Represents a section of character data in a documentation comment.
Represents a block of code in a documentation comment.
Documents how to use a code object.
Documents that an exception can be thrown by a method, property, event, or indexer.
Represents a section of italic text in a documentation comment.
Allows for documentation comments to be included from a separate file.
Represents a list in a documentation comment.
Represents the header of a DocList in a documentation comment.
Represents an item in a DocList in a documentation comment.
Represents a separate paragraph in a documentation comment.
Documents a method or indexer parameter.
Embeds a reference to a method or indexer parameter in a documentation comment.
Documents the access rights of a member.
Provides additional comments for a code object.
Documents the return value of a method.
Embeds a reference to a type or member in a documentation comment.
Documents a reference to a type or member that should be presented in a "See Also" section.
Provides a summary comment for a code object.
Represents an unrecognized or orphaned (missing start or end) tag in a documentation comment.
Represents plain-text user documentation of code.
Documents a type parameter.
Embeds a reference to a type parameter in a documentation comment.
Documents the value of a property.
Performs a member lookup (either directly on a namespace or type, or indirectly on the evaluated type of the expression on the left side).
Represents the "while" portion of a DoWhile loop, and does NOT have a body. This class works as a child of the While class, which displays as a "do" loop when IsDoWhile is set to true - it should not be used directly.
Represents a symbolic reference that is part of a dynamically-typed expression (and therefore is unresolved until runtime).
Represents a reference to a 'dynamic' type.
Marks the end of an IfDirective.
Represents the end of a section of code that can be collapsed, and has optional descriptive text.
Represents a constant value of a specified enum type, stored in the underlying type of the enum.
Declares an enumerated type, and includes a name and a body with a list of identifiers (with optional assigned values). It can also optionally have modifiers and/or a base type.
Represents the declaration of an individual enum member. Can only be used as a child of MultiEnumMemberDecl, not as a stand-alone declaration.
The Equal operator checks if the left Expression is equal to the right Expression.
Forces the compiler to emit an error message.
Represents an assembly that failed to load.
Declares a property-like event, with add/remove accessors.
The common base class of all expressions.
Used together with compiler command-line options to create additional root-level namespaces.
Represents a reference to an ExternAlias namespace statement, or to the 'global' namespace.
Determines if an expression evaluates to false.
Represents a class member variable declaration.
Has a body that is ensured to always be executed whenever its parent Try block is exited for any reason.
Fixes moveable variable(s) for the duration of the statment in an unsafe context.
Represents a declaration of a fixed-size buffer in a StructDecl in an unsafe context.
Represents a 'for' loop.
Defines an iteration variable and a collection (or array) plus a body (a statement or block) that is repeatedly executed for each variable in the collection.
Represents a group of loaded assemblies for a particular target framework version, loaded into a particular AppDomain.
Represents a LINQ 'from' clause.
Represents a generic method declaration with type parameters.
Represents a special type of method used to read the value of a property.
The GreaterThan operator checks if the left Expression is greater than the right Expression.
The GreaterThanEqual operator checks if the left Expression is greater than or equal to the right Expression.
Represents a LINQ 'group' clause.
Marks the beginning of a section of conditionally compiled code.
Represents an index into an array or type with an indexer. Array indexes must be integral. Indexers may index with any type.
Represents an "indexer" - an indexed property.
Represents the initialization of an array, object, or collection with a list of Expressions.
Declares an interface, which includes a name plus a body, along with various optional modifiers. Interfaces define contracts - they have no fields or code.
Checks if an Expression can be converted to the specified type, returning true if so.
Represents a LINQ 'join' clause.
Represents a named entry point that can be targeted by one or more Goto statements.
Represents a reference to a Label.
Represents an un-named method that can be assigned to a delegate. It's very similar to an AnonymousMethod, just with newer, simplified syntax, and it supports implicit types for its parameters.
The LessThan operator checks if the left Expression is less than the right Expression.
The LessThanEqual operator checks if the left Expression is less than or equal to the right Expression.
Represents a LINQ 'let' clause.
Used to control embedded line number information.
Represents a literal value of a particular type (string, int, bool, etc).
Represents an Assembly that has been loaded into memory.
Represents a local variable declaration.
Represents a reference to a LocalDecl.
Maintains a critical section on the provided object while the body of the statement is executing.
Specifies that an identifier is in the specified namespace - either 'global' or an aliased root-level namespace name (specified either with a 'using' or extern alias directive).
Returns a TypedReference object for the specified variable. This is an undocumented C# operator.
Represents a generated message associated with a CodeObject (error, warning, suggestion, or hint).
Represents a named Block of code with optional parameters and an optional return value. Various optional modifiers can also be used (the default is 'private').
Returns the remainder of the division of one Expression by another.
Static helper methods and extension methods for Modifiers.
Represents an AssemblyDefinition that has been loaded into memory using Mono.Cecil.
Represents the declaration of the single valid member of an EnumDecl, which has one or more EnumMemberDecl children. It has no name (its children have names), and its type is the base type of the parent EnumDecl, or it defaults to int. MultiEnumMemberDecls are implicitly constants (and therefore also static).
Represents a compound field declaration - the declaration of multiple fields of the same type in a single statement.
Represents a compound fixed-size buffer declaration - the declaration of multiple fixed-size buffers of the same type in a single statement.
Represents a compound local variable declaration - the declaration of multiple local variables of the same type in a single statement.
Multiplies one Expression by another.
Represents an argument expression associated with a specific parameter of a method (or indexer).
Represents a group of named code or metadata objects (INamedCodeObjects and/or IMemberDefinitions/MemberInfos) with the same name, such as overloaded methods or other name collisions. Differs from NamedCodeObjectGroup in that it can hold metadata (IMemberDefinition/MemberInfo) in addition to INamedCodeObjects.
Returns the string name of the specified code object.
Represents a namespace of type declarations and optional child namespaces.
Declares a namespace plus a body of declarations that belong to it.
Represents a reference to a Namespace.
Negates an Expression.
The NewArray operator is used to create new array instances.
Constrains the type that a TypeParameter can represent to one with a default constructor.
The NewObject operator is used to create new object instances of class, struct, delegate, or anonymous types.
Checks if an Expression is false.
The NotEqual operator checks if the left Expression is NOT equal to the right Expression.
Performs a null-safe member lookup (either directly on a namespace or type, or indirectly on the evaluated type of the expression on the left side). Has the same behavior as Dot, except that if the left side evaluates to null at runtime no exception is thrown.
Represents a null-safe index into an array or type with an indexer. Array indexes must be integral. Indexers may index with any type.
The common base class of all operations (binary, unary, or other).
Performs a conditional (logical) 'or' of two boolean Expressions.
Represents a LINQ 'order by' clause.
Represents a child expression of a LINQ OrderByClause.
Allows a variable being passed as a parameter to be marked as an 'out' parameter. This is a special pseudo-operator that is only for use in this special case.
Represents the declaration of a parameter to a method.
Obtains the variable to which a pointer points in an unsafe context.
Performs a member lookup on a pointer in an unsafe context.
Has no effect (exists for convenience only).
Used to manage checksum information for files.
Used to turn warnings on or off.
Represents a collection of CodeUnit objects (files) that are compiled together into some type of target (such as a .DLL or .EXE file).
Configuration settings for a Project.
Represents a file item in a Project file.
Represents unhandled data in a Project file.
Represents a project reference to another project in the same solution.
Represents a "property" - a virtual field accessed only by calling get and/or set methods.
Allows a variable being passed as a parameter to be marked as a 'ref' parameter. This is a special pseudo-operator that is only for use in this special case.
Represents an Assembly that has been loaded into memory using .NET reflection.
Returns the value portion of the specified TypedReference, cast to the specified type. This is an undocumented C# operator.
Represents the start of a section of code that can be collapsed, and has optional descriptive text.
Represents a special type of method used to remove from an event.
Indicates that execution should return from the current method, and has an optional Expression to be evaluated as the return value.
Represents the top-level namespace (either a project's global namespace, or an extern alias namespace).
Represents a LINQ 'select' clause.
Represents a special type of method used to write the value of a property.
Returns the size of the specified type.
Represents a collection of Project objects that are logically grouped (and compiled) together.
Represents a global-level section of configuration data in a solution file.
Represents a project entry in a Solution file.
Represents a project-level section of configuration data in a solution file.
Allocates memory from the call stack in an unsafe context.
Constrains the type that a TypeParameter can represent to a value type.
Declares a struct, includes a name plus a body, along with various optional modifiers. Unlike classes, structs are value types.
Subtracts one Expression from another.
Determines if one SymbolicRef is equivalent to another one, meaning they both refer to the same code object or type.
Used temporarily during the parsing process for special situations - specifically, as a temporary holder of compiler directives that need to be returned to a higher level.
Represents a call to another constructor in the same class (constructor initializer).
Represents a reference to the current object instance.
Determines if an expression evaluates to true.
Constrains the type that a TypeParameter can represent to the specified type (or a derived type). The constraining type can be a class type, an interface type, or a type parameter type.
Returns the system type object for the specified type.
Represents a type parameter of a generic type or method declaration.
Determines if one TypeRefBase is equivalent to another one, meaning they both refer to the same type.
Explicitly turns OFF overflow checking (exceptions) for an Expression.
Contains a body of code for which overflow checking is explicitly turned off.
Allows for removing an existing definition of a "pre-processor" symbol - may only appear at the top of a CodeUnit (file)!
Represents a list of one or more unrecognized identifiers or symbols (UnresolvedRefs). If it's part of a larger expression (as opposed to being a stand-alone expression), then the last entry in the list will itself be a valid child expression.
Represents a symbolic reference that hasn't been resolved to a direct reference (includes references that are unresolved because they are ambiguous, or because the type arguments or method arguments don't match in number or type).
This is a special class used for explicit interface implementations of indexers, and also for an explicit reference to an indexer member of a type (these are normally implicit, but explicit references are legal in doc comments).
Contains a body of code that is marked as "unsafe".
Forces the compiler to emit a warning message.
Represents a LINQ 'where' clause.
Includes a conditional expression plus a body (a statement or block) that is repeatedly executed as long as the expression evaluates to true. If IsDoWhile is true, the expression is evaluated at the bottom of the block ("do-while").
Signals the end of an iterator.
Yields the current value of an iterator.
This interface is implemented by all code objects that can have a lambda expression as a body instead of a block.
This interface is implemented by all code objects that have Modifiers.
This interface is implemented by all CodeObjects that have a Name property, and can be referenced symbolically.
This interface allows for use of the Visitor design pattern to traverse a tree of CodeObjects.
Annotation formatting flags.
Valid attribute target types.
Rendering behavior flags (passed through rendering methods).
Comment type flags.
The type of a LineDirective.
Load options - used when loading a Solution, Project, or CodeUnit.
Used for status callbacks during the load process to monitor progress and update any UI.
The severity of a message.
The source of a message.
These modifiers are usable on various code objects to specify access and special behaviors.
The direction of an Ordering.
These modifiers are usable on method parameters to specify special behavior. Only a single modifier is allowed for each parameter.
The action of a PragmaWarningDirective.
Enumeration of build actions.
Enumeration of copy actions.
Enumeration of debug types.
Enumeration of error reporting types.
Enumeration of types of serialization generation.
Enumeration of output types.
Valid type parameter variance specifiers.
Flags used to handle pointers, const state, and type formatting.