Nova.CodeDOM Namespace

The common base class of GetterDecl, SetterDecl, AdderDecl, and RemoverDecl.

The common base class of SetterDecl, AdderDecl, and RemoverDecl.

Adds one Expression to another.

Adds one Expression to another, and assigns the result to the left Expression. The left Expression must be an assignable object ("lvalue").

Represents a special type of method used to add to an event.

Takes the address of a fixed variable in an unsafe context.

Represents an alias to a Namespace or a type (TypeDecl, or TypeDefinition/Type).

Represents a reference to an Alias, which can in turn refer to a NamespaceRef or a TypeRef (or an UnresolvedRef).

Performs a conditional (logical) 'and' of two boolean Expressions.

The common base class of all code annotations, including user comments (derived from CommentBase), code attributes (Attribute), compiler directives (derived from CompilerDirective), and generated messages (derived from Message).

Represents an un-named method that can be assigned to a delegate.

The common base class of LambdaExpression and AnonymousMethod.

Represents a reference to an AnonymousMethodBase (AnonymousMethod, or LambdaExpression).

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.

The common base class of all operators with a variable list of arguments (Call, Index, NewOperator, StackAlloc, ArgList, RefValue).

Converts an Expression to the specified type, returning null if the conversion can't be done.

Represents a project reference to an external assembly.

Assigns the right Expression to the left Expression. Also the common base class of all compound assignment operators (AddAssign, BitwiseAndAssign, BitwiseOrAssign, BitwiseXorAssign, DivideAssign, LeftShiftAssign, ModAssign, MultiplyAssign, RightShiftAssign, SubtractAssign).

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).

The common base class of all user-defined types with optionally declared base types (ClassDecl, StructDecl, InterfaceDecl, and EnumDecl).

Represents a reference to the base class of the current object instance.

The common base class of all binary arithmetic operators (Add, Subtract, Multiply, Divide, Mod).

The common base class of all binary bitwise operators (BitwiseAnd, BitwiseOr, BitwiseXor).

The common base class of all binary operators that evaluate to boolean values (RelationalOperator [common base of Equal, NotEqual, GreaterThan, LessThan, GreaterThanEqual, LessThanEqual], And, Or, Is).

The common base class of all binary operators (BinaryArithmeticOperator, BinaryBitwiseOperator, BinaryBooleanOperator, BinaryShiftOperator, Assignment, As, Dot, IfNullThen, Lookup, PointerMember).

The common base class of LeftShift and RightShift.

Performs a boolean AND operation on two Expressions.

Performs a boolean AND operation on two Expressions, and assigns the result to the left Expression. The left Expression must be an assignable object ("lvalue").

Performs a boolean OR operation on two Expressions.

Performs a boolean OR operation on two Expressions, and assigns the result to the left Expression. The left Expression must be an assignable object ("lvalue").

Performs a boolean XOR operation on two Expressions.

Performs a boolean XOR operation on two Expressions, and assigns the result to the left Expression. The left Expression must be an assignable object ("lvalue").

Represents the body of a BlockStatement or AnonymousMethodBase (containing a sequence of 0 or more CodeObjects).

Represents a stand-alone block of code restricted to a local scope (surrounded by braces).

The common base class of all Statements that can have a Block as a body (NamespaceDecl, TypeDecl, MethodDeclBase, PropertyDeclBase, BlockDecl, IfBase, Else, Switch, SwitchItem, For, ForEach, While, Try, Catch, Finally, Using, Lock, CheckedBlock, UncheckedBlock, Unsafe, Fixed).

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.

Has an optional Expression or LocalDecl (which must evaluate to an Exception type), plus a body that is executed if an exception of the specified type is caught. The Expression may be omitted (null), in which case all exceptions are caught.

Explicitly turns ON overflow checking (exceptions) for an Expression.

Contains a body of code for which overflow checking is explicitly turned on.

The common base class of the Checked and Unchecked operators.

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.

Represents a 'listed' code Annotation and its location (Project and CodeUnit). Listed annotations include all Messages (error, warning, suggestion, etc) and also special Comments.

The common base class of all code objects.

Declares a unit of independent code that belongs to the root-level namespace (also known as a "compilation unit"). Usually is the contents of a source file, but it can optionally be in-memory only. A CodeUnit is essentially a NamespaceDecl of the global namespace.

Represents user comments, and may either be independent or associated with another CodeObject.

The common base class of all comment classes (Comment and DocComment).

The common base class of all compiler directives (ConditionalDirective, MessageDirective, SymbolDirective, PragmaDirective, LineDirective).

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.

The common base class of IfDirective, ElIfDirective, and ElseDirective.

The common base class of IfDirective, ElIfDirective, ElseDirective, and EndIfDirective.

The common base class of IfDirective and ElIfDirective.

Represents one or more contraints on a type parameter.

Represents a special method used to initialize an instance of a ClassDecl or StructDecl. If a constructor is static, it can't have any parameters, and can't have any other modifiers except extern (in which case it has no body) or unsafe.

The common base class of BaseInitializer and ThisInitializer.

Represents a reference to a ConstructorDecl or MethodDefinition/ConstructorInfo.

Causes execution to jump back to the top of the active loop.

Represents a user-defined conversion operator.

Represents a group of local variable declarations that are initialized from a tuple.

The DeconstructionExpr operator is used to deconstruct a tuple, assigning its members to variables, properties, etc (any l-value).

Decrements an Expression, which should evaluate to a VariableRef (or a property or indexer access).

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.

Represents a discard variable declaration.

Represents a reference to the global unassigned, write-only, typeless, "discard" variable.

Divides one Expression by another.

Divides one Expression by another, and assigns the result to the left Expression. The left Expression must be an assignable object ("lvalue").

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.

The common base class of all documentation comment tags that have a 'cref' attribute (DocSee, DocSeeAlso, DocException, DocPermission).

Represents user documentation of code, and is also the common base class of DocText, DocCodeRefBase, DocNameBase, DocB, DocC, DocCode, DocCDATA, DocExample, DocI, DocInclude, DocPara, DocRemarks, DocSummary, DocTag, DocValue, DocList, DocListHeader, DocListItem, DocListDescription, DocListTerm.

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 description of a DocListItem in a DocList 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 the term of a DocListItem in a DocList in a documentation comment.

The common base class of all documentation comment tags that have a 'name' attribute (DocParam, DocParamRef, DocTypeParam, DocTypeParamRef).

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 a reference to a .NET CLI Tool package. (used by VS2017 format project files)

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.

Used for optional compilation of code, must be preceded by an IfDirective or ElIfDirective, and followed by one of ElIfDirective, ElseDirective, or EndIfDirective.

Represents a non-conditional alternative portion of an If or ElseIf (as a child of one of those object types).

Used for optional compilation of code, must be preceded by an IfDirective or ElIfDirective, and followed by an EndIfDirective.

Represents a conditional alternative portion of an If or ElseIf (as a child of one of those object types).

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.

Represents a reference to an EnumMemberDecl (a member of an EnumDecl type 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.

Represents a reference to an EventDecl or EventDefinition/EventInfo.

The common base class of all expressions.

This is a special TypeRef that refers to a ExpressionTDelegate type.

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.

Represents a reference to a FieldDecl or a FieldDefinition/FieldInfo.

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.

Redirects execution to the specified Label or SwitchItem (Case or Default).

The common base class of LabelRef and SwitchItemRef.

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.

Represents conditional flow control, and includes a conditional expression, a body, and an optional Else or ElseIf statement.

The common base class of If and ElseIf.

Marks the beginning of a section of conditionally compiled code.

Returns the right Expression if the left Expression is null, otherwise it returns the left Expression.

Allows a variable being passed as a parameter to be marked as an 'in' parameter. This is a special pseudo-operator that is only for use in this special case.

Increments an Expression, which should evaluate to a VariableRef (or a property or indexer access).

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 a reference to an IndexerDecl or a PropertyInfo for an indexer.

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.

Shifts the bits of the left Expression to the LEFT by the number of bits indicated by the right Expression.

Shifts the value of the left Expression LEFT by the value of the right Expression, and assigns the result to the left Expression. The left Expression must be an assignable object ("lvalue").

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 local variable declaration inside certain expressions, also known as pattern-matching (C# 7 feature).

Represents a reference to a LocalDecl or LocalDeclExpr.

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).

The common base class of RegionDirective, EndRegionDirective, ErrorDirective, and WarningDirective.

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').

The common base class of MethodDecl, GenericMethodDecl, ConstructorDecl, and DestructorDecl.

Represents a reference to a MethodDeclBase (common base of MethodDecl, GenericMethodDecl, ConstructorDecl, DestructorDecl), AnonymousMethodBase (common base of AnonymousMethod, LambdaExpression), or MethodDefinition/MethodInfo.

Returns the remainder of the division of one Expression by another.

Gets the remainder of the division of one Expression by another, and assigns it to the left Expression. The left Expression must be an assignable object ("lvalue").

Static helper methods and extension methods for Modifiers.

Derives from a Mono Cecil BaseAssemblyResolver in order to resolve assemblies on demand in the scope of a certain Project.

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.

Multiplies one Expression by another, and assigns the result to the left Expression. The left Expression must be an assignable object ("lvalue").

Represents an argument expression associated with a specific parameter of a method (or indexer).

Represents a dictionary of INamedCodeObjects, allowing multiple entries with the same name. Differs from NamedObjectDictionary in that it can only hold INamedCodeObjects, and NOT metadata (IMemberDefinition/MemberInfo).

Represents a group of named code objects (INamedCodeObjects) with the same name, such as overloaded methods or other name collisions. Differs from NamedObjectGroup in that it can only hold INamedCodeObjects, and NOT metadata (IMemberDefinition/MemberInfo).

Represents a dictionary of named code or metadata objects (INamedCodeObjects and/or IMemberDefinitions/MemberInfos), allowing multiple entries with the same name. Differs from NamedCodeObjectDictionary in that it can hold metadata (IMemberDefinition/MemberInfo) in addition to INamedCodeObjects.

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.

Represents a dictionary of Namespaces and types (TypeDecls and/or TypeDefinitions/Types), allowing multiple entries with the same name.

Represents a group of types (TypeDecls and/or TypeDefinitions/Types) and/or Namespaces, with the same name (the contained objects are of type 'object').

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.

The common base class of NewObject and NewArray.

The NewTuple operator is used to create a new tuple instance.

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.

Represents a reference to a TypeParameter (or GenericParameter/Type) from outside the generic type or method declaration that declares it, and exists only temporarily until it is replaced by a concrete type or TypeParameterRef during the type argument evaluation process.

The common base class of all operations (binary, unary, or other).

Represents a user-overloaded operator. The boolean ('true' and 'false') operators use the derived class BooleanOperatorDecl, and conversion operators use the derived class ConversionOperatorDecl.

Represents a reference to an OperatorDecl or MethodDefinition/MethodInfo for an overloaded operator.

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 an 'out' local variable declaration that is passed to a method call as an argument expression (C# 7 feature).

Represents a reference to a NuGet package. (used by VS2017 format project files)

Represents the declaration of a parameter to a method.

Represents a reference to a ParameterDecl or a ParameterDefinition/ParameterInfo. Similar to a LocalRef, but represents a parameter passed to the current 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).

Decrements an Expression *after* it is evaluated. Use Decrement instead when possible, because it's more efficient.

Increments an Expression *after* it is evaluated. Use Increment instead when possible, because it's more efficient.

The common base class of all postfix unary operators (PostIncrement and PostDecrement).

Used to manage checksum information for files.

The common base class of all pragma directives (PragmaChecksumDirective, PragmaWarningDirective).

Used to turn warnings on or off.

The common base class of all prefix unary operators (AddressOf, Cast, Complement, Decrement, False, Increment, Negative, Not, PointerIndirection, Positive, True).

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.

The common base class of PropertyDecl, IndexerDecl, and EventDecl.

Represents a reference to a PropertyDecl or PropertyDefinition/PropertyInfo.

The common base class of QueryExpression and QueryContinuation.

The common base class of all query clauses that can be part of a query base (FromClause, LetClause, JoinClause, WhereClause, OrderByClause, SelectClause, GroupClause).

The common base class of all query clauses (QueryBodyClause [common base of FromClause, LetClause, JoinClause, WhereClause, OrderByClause], SelectOrGroupClause [common base of SelectClause, GroupClause]).

Represents a continuation of a LINQ query, consisting of 'into' with an identifier, optional QueryBodyClauses, a SelectOrGroupClause, and an optional QueryContinuation.

Represents a LINQ query, consisting of a FromClause with optional QueryBodyClauses, a SelectOrGroupClause, and an optional QueryContinuation.

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.

The common base class of AssemblyReference, ProjectReference, and COMReference.

Represents an Assembly that has been loaded into memory using .NET reflection.

The common base class of the Ref and In/Out pseudo-operators.

Returns the corresponding Type for the specified TypedReference. This is an undocumented C# operator.

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.

The common base class of all relational operators (Equal, NotEqual, GreaterThan, LessThan, GreaterThanEqual, LessThanEqual).

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.

Shifts the bits of the left Expression to the RIGHT by the number of bits indicated by the right Expression.

Shifts the value of the left Expression RIGHT by the value of the right Expression, and assigns the result to the left Expression. The left Expression must be an assignable object ("lvalue").

Represents the top-level namespace (either a project's global namespace, or an extern alias namespace).

Represents a LINQ 'select' clause.

The common base class of SelectClause and GroupClause.

The common base class of ThisRef and BaseRef.

Represents a special type of method used to write the value of a property.

The common base class of all operators with a fixed single argument (Ref, Out, Checked, Unchecked, TypeOf, SizeOf, DefaultValue).

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.

The common base class of all statements (BlockStatement, VariableDecl, UsingDirective, Break, Continue, Goto, Label, Return, Throw, YieldStatement, DoWhile, Alias, ExternAlias).

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.

Subtracts one Expression from another, and assigns the result to the left Expression. The left Expression must be an assignable object ("lvalue").

Represents conditional flow control, and consists of a constant expression (of integral or string type) along with one or more Case or Default child statements.

The common base class of the Case and Default statements (of a Switch).

Represents a reference to a SwitchItem (Case or Default).

The common base class of DefineSymbol and UnDefSymbol.

The common base class of all symbolic references, such as NamespaceRef, TypeRefBase (common base of TypeRef, MethodRef, UnresolvedRef), VariableRef, SelfRef, GotoTargetRef, ExternAliasRef, and DirectiveSymbolRef.

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.

Indicates that an exception should be thrown, and has an expression that should evaluate to an object of type Exception. If the expression is omitted (null), then any currently active exception (inside a Catch body) is re-thrown.

Indicates that an exception should be thrown, and has an expression that should evaluate to an object of type Exception. If the expression is omitted (null), then any currently active exception (inside a Catch body) is re-thrown.

Represents a Message associated with a parse Token.

Determines if an expression evaluates to true.

Contains a body of code that is scoped to one or more Catch statements and/or a Finally statement.

Represents a reference to a Tuple (a C# 7 feature, using the ValueTuple class for the runtime implementation).

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.

The common base class of all user-defined type declarations (ClassDecl, StructDecl, InterfaceDecl, EnumDecl, and DelegateDecl).

Returns the system type object for the specified type.

The common base class of the TypeOf, SizeOf, and DefaultValue operators.

Represents a type parameter of a generic type or method declaration.

The common base class of ClassConstraint, StructConstraint, NewConstraint, TypeConstraint, and UnmanagedConstraint.

Represents a reference to a TypeParameter (or GenericParameter/Type) from within the generic type or method declaration that declares it.

Represents a reference to an ITypeDecl (TypeDecl, TypeParameter, Alias) or an external TypeDefinition/Type.

Handles references to generic and/or array types, and is the common base class of TypeRef, MethodRef (because it can be treated as a delegate type, and can have generic parameters), and UnresolvedRef (because unresolved symbols can have generic parameters and array ranks).

Determines if one TypeRefBase is equivalent to another one, meaning they both refer to the same type.

The common base class of all unary operators (PreUnaryOperator, PostUnaryOperator).

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)!

Constrains the type that a TypeParameter can represent to a reference type.

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".

Enforces the disposal of an object when it's no longer needed. It accepts either an Expression or a LocalDecl, and internally wraps this in a try/finally that calls Dispose() on the object (which must implement the IDisposable interface).

Imports the contents of a Namespace or a Type (as of C# 6.0) into the current scope.

Represents the declaration of an implicit 'value' parameter for a GetterDecl, AdderDecl, or RemoverDecl.

The common base class of FieldDecl, LocalDecl, ParameterDecl, and EnumMemberDecl.

The common base class of all variable references (FieldRef, LocalRef, ParameterRef, EnumMemberRef, PropertyRef, IndexerRef, EventRef).

Represents a reference to an implicit type (one that is determined at compile-time). Implicit types are represented as 'var', and can currently only be used for LocalDecls or LocalDeclExprs. They are also used internally (not displayed) for implicitly-typed ParameterDecls of LambdaExpressions.

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.

The common base class of YieldReturn and YieldBreak.

This interface is implemented by all code objects that can have a Block for a body (subclasses of BlockStatement, AnonymousMethodBase, DocCode).

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 can be stored as files, which includes Solution, Project, and CodeUnit.

This interface is implemented by all code objects that have Modifiers.

This interface is implemented by MultiFieldDecl, MultiLocalDecl, MultiEnumMemberDecl, and MultiFixedSizeBufferDecl.

This interface is implemented by all CodeObjects that have a Name property, and can be referenced symbolically.

This interface is implemented by all code objects that represent namespace declarations (Namespace and Alias).

This interface is implemented by all code objects that have parameters (MethodDeclBase [MethodDecl, GenericMethodDecl, ConstructorDecl, DestructorDecl], IndexerDecl, DelegateDecl, AnonymousMethodBase [AnonymousMethod, LambdaExpression]).

This interface is implemented by all code objects that represent type declarations, which includes TypeDecl, TypeParameter, and Alias.

This interface is implemented by all code objects that have TypeParameters (TypeDecl, GenericMethodDecl).

This interface is implemented by all code objects that represent variable declarations, which includes VariableDecl (ParameterDecl, LocalDecl, FieldDecl, EnumMemberDecl), and PropertyDeclBase (PropertyDecl, EventDecl, IndexerDecl).

This interface allows for use of the Visitor design pattern to traverse a tree of CodeObjects.

Annotation formatting flags.

Valid attribute target types.

Formatting flags.

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.