Namespace Metalama.Framework.Code

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.

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.

Extension methods for the IRef<T> interface.

Extension methods for RefKind.

Provides extension methods for IType.

Exposes methods that return instances of the IType interface.

Information about an async method, returned by the GetAsyncInfo(IMethod) extension method of IMethod.

Gives access to the aspects, options and annotations on a declaration.

Information about an iterator method, returned by the GetIteratorInfo(IMethod) extension method of IMethod.

Encapsulates a string that uniquely identifies a declaration 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.

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.

An annotation is an arbitrary but serializable object that can then be retrieved using the GetAnnotations<TAnnotation>() method of the Enhancements<T>(T) object. Annotations are a way of communication between aspects or classes of aspects.

Represents an assembly (typically a reference assembly).

Represents an assembly identity, used in project references.

Represent a custom attributes.

Represent the members of a custom attribute, but not 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.

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. To create an expression, use ExpressionFactory or ExpressionBuilder. Note that IField, IProperty and IParameter also implement the IExpression interface.

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.

An interface, common to INamedType and IMethod, that represents a generic declaration, i.e. a declaration with type parameters.

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 class, struct, interface, enum, or delegate.

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.

Represents a reference to an IDeclaration or IType, which is valid across different compilation versions (i.e. ICompilation) and, when serialized, across projects and processes. References can be resolved using GetTarget(ICompilation, ReferenceResolutionOptions), given an compilation, or using the GetTarget<T>(IRef<T>, ReferenceResolutionOptions) extension method for the compilation of the current context.

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

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 parameter of a method or type.

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

Describes the kind of constructor initializer.

Describes conversion between types possible during comparison.

Kinds of IDeclaration.

Kinds of IDeclarationOrigin.

Options for the GetDerivedTypes(INamedType, DerivedTypesOptions) method.

Kinds of iterators.

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

Kinds of IMethodBase.

Kinds of operators.

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

Options that determine how GetTarget(ICompilation, ReferenceResolutionOptions) and related methods work.

Special types, such as Void.

Kinds of IType.

Specifies the kind variance: In, Out or None.

Enumerates the different abilities of a field or property to be written (set).