Namespace Metalama.Framework.Code

Provides extension methods for the Accessibility type to compare accessibility levels.

Extension methods for the IAttribute interface.

Reserved for future use. Specifies the context for which the display string must be generated.

Defines the formatting options of ToDisplayString(CodeDisplayFormat?, CodeDisplayContext?). Only well-known instances of this classes, exposed as properties, are currently supported.

Extension methods for the ICompilation interface.

Provides extension methods to the IConstructorCollection interface.

Extension methods for IDeclaration.

Provides extension methods to work with generic declarations.

Extension methods for the IMember interface.

Provides extension methods to the IMethodCollection interface.

Extension methods for the IMethod interface.

Extension methods for the INamedType interface.

Defines extension methods for the OperatorKind class.

Extension methods for resolving IRef<T> references to their target declarations.

Extension methods for RefKind.

Extension methods for ReferenceKinds.

Extension methods for reflection types to convert them to Metalama expressions.

Provides extension methods for IType.

Provides methods to obtain IType instances from reflection types, special types, or by constructing new types.

Provides information about the async characteristics of a method, returned by the GetAsyncInfo(IMethod) extension method of IMethod.

Provides access to aspects, options, and annotations applied to a declaration. This allows querying metadata added by aspects and accessing hierarchical configuration.

Provides information about the iterator characteristics of a method, returned by the GetIteratorInfo(IMethod) extension method of IMethod.

Encapsulates a string that uniquely identifies a declaration within a compilation and that is safe to persist in a file or serialize across processes.

Encapsulates a string that uniquely identifies a type within a compilation (except in the situation where the compilation contains several assemblies providing types of the same name) and that is safe to persist in a file.

Represents a syntax node in source code. Using Metalama.Framework.Sdk you can use ToSyntaxNodeOrToken to convert it to a Roslyn object.

Represents a span of source code.

Represents a typed value that can be defined, defined to null, or undefined. Used to represent default values, for instance DefaultValue, or attribute arguments.

A non-generic base interface for the generic IAnnotation<T>. You should always implement the generic interface.

Represents an annotation - an arbitrary serializable object that aspects can attach to declarations to communicate information to other aspects or subsequent compilation phases.

Represents an assembly (typically a reference assembly).

Represents an assembly identity, used in project references.

Represents a custom attribute applied to a declaration.

Represents the data of a custom attribute (type, constructor arguments, and named arguments) without its relationship to the containing declaration.

Represents a set of types compiled together. See also IProject.

Exposes a Compilation property.

Represents an instance constructor or a static constructor.

Represent a declaration.

A service that caches declarations of the current compilation. It is typically used to cache often-used declarations across aspect instances.

Allows to get instances of the IType interface or to test for type equality or inheritance.

Represents the origin of the code, i.e. the artefact or function created the declaration.

Defines a method ToDisplayString(CodeDisplayFormat?, CodeDisplayContext?) that renders the current declaration into a human-readable string.

Represent an event.

A compile-time representation of a run-time expression, representing C# syntax that will be generated in transformed code.

Represents an extension block.

Represents a field. Note that fields can be promoted to properties by aspects.

A base interface for IField and IProperty.

A base interface for IProperty, IField and IIndexer.

Represents a generic declaration with type parameters, common to INamedType and IMethod.

Represents a context in which type parameters are mapped to their values.

A base interface for IProperty and IEvent. Exposes GetAccessor(MethodKind).

Represents a method, constructor, or indexer.

Exposes a Type property.

Represents an indexer, i.e. a this[*] property.

Represents a managed resource.

Base interface for IMethod, IFieldOrProperty, IEvent, but not INamedType.

Base interface for IMethod, IFieldOrPropertyOrIndexer, IEvent, and INamedType.

Represents a method, but not a constructor.

Represents a method or a constructor.

Represents a declaration that has a name.

Represents a named type: class, struct, interface, enum, delegate, or record.

Represents a namespace inside the current compilation or an external assembly, according to the DeclaringAssembly property.

Represents a namespace or a named type.

A compile-time representation of a run-time object creation expression.

Represents a parameter of a method or property.

Represents a property.

A base interface for IProperty and IIndexer.

Represents a reference to an IDeclaration or IType that remains valid across different compilation versions (i.e., ICompilation) and, when serialized, across projects and processes. All objects implementing this interface also implement the strongly-typed IRef<T>.

Represents a strongly-typed reference to an IDeclaration or IType that remains valid across different compilation versions (i.e., ICompilation) and, when serialized, across projects and processes.

Represents an IExpression defined in source code, as opposed to a generated expression.

Represents an element of a tuple type.

Represents a tuple type, such as (int, string) or (decimal Quantity, string ProductCode).

Represents a constructed type, for instance an array, a generic type instance, a pointer. A class, struct, enum or delegate are represented as an INamedType, which derive from IType.

Represents a generic type parameter of a method or type, such as T in List<T>.

Accessibility of types and members, for instance Private or Public.

Describes the kind of constructor initializer. A constructor initializer is the optional : base(...) or : this(...) clause that appears after the constructor parameter list and invokes another constructor before the current constructor body executes.

Describes conversion between types possible during comparison.

Kinds of IDeclaration.

Kinds of IDeclarationOrigin.

Options for the GetDerivedTypes(INamedType, DerivedTypesOptions) method.

Specifies the kind of enumerable or enumerator type returned by a method.

Enumerates the possible execution scopes of a declaration i.e. RunTime, CompileTime or RunTimeOrCompileTime.

Specifies the kind of field.

Kinds of IMethod.

Categorizes operator kinds. To get the OperatorCategory from an OperatorKind, use the GetCategory(OperatorKind) extension method.

Kinds of operators.

Defines strategies to compare two instances of the IRef<T> interface.

Kinds of parameters, such as ref, in, out...

Enumerates all kinds of references.

Identifies well-known types for efficient type checking without string comparisons.

Kinds of IType.

Specifies type kind constraints for generic type parameters.

Specifies whether a type parameter belongs to a type or a method.

Specifies the kind variance for type parameters: In, Out or None.

Enumerates the different abilities of a field or property to be written (set). Values are ordered from most restrictive (None) to least restrictive (All).