Report a bug
If you spot a problem with this page, click here to create a Bugzilla issue.
Improve this page
Quickly fork, edit online, and submit a pull request for this page. Requires a signed-in GitHub account. This works well for small changes. If you'd like to make larger changes you may want to consider using a local clone.


Defines a D type.

Source mtype.d

pure nothrow @nogc @safe bool MODimplicitConv(MOD modfrom, MOD modto);
Return !=0 if modfrom can be implicitly converted to modto
pure nothrow @nogc @safe MATCH MODmethodConv(MOD modfrom, MOD modto);
Return MATCH.exact or MATCH.constant if a method of type '() modfrom' can call a method of type '() modto'.
pure nothrow @nogc @safe MOD MODmerge(MOD mod1, MOD mod2);
Merge mod bits to form common mod.
nothrow @safe void MODtoBuffer(ref OutBuffer buf, MOD mod);
Store modifier name into buf.
pure nothrow const(char)* MODtoChars(MOD mod);

pure nothrow @safe string MODtoString(MOD mod);
a human readable representation of mod, which is the token mod corresponds to
pure nothrow @nogc @safe string trustToString(TRUST trust);
Pick off one of the trust flags from trust, and return a string representation of it.
pure nothrow @nogc @safe StorageClass ModToStc(uint mod);
Convert MODxxxx to STCxxx
pure nothrow @nogc @safe bool isSomeChar(TY ty);
Returns true if ty is char, wchar, or dchar
enum DotExpFlag: int;
dotExp() bit flags
enum Covariant: int;
Result of a check whether two types are covariant
types are distinct
types are covariant
arguments match as far as overloading goes, but types are not covariant
cannot determine covariance because of forward references
abstract class Type: dmd.ast_node.ASTNode;
final const size_t getUniqueID();
Returns a non-zero unique ID for this Type, or returns 0 if the Type does not (yet) have a unique ID. If semantic() has not been run, 0 is returned.
final const const(char)* toChars();

final char* toPrettyChars(bool QualifyTypes = false);
For pretty-printing a type.
static void deinitialize();
Deinitializes the global state of the compiler.
This can be used to restore the state set by _init to its original state.
final const nothrow void modToBuffer(ref OutBuffer buf);
Store this type's modifier name into buf.
final const nothrow char* modToChars();
Return this type's modifier name.
bool isAssignable();
When T is mutable,

Given T a, b; Can we bitwise assign: a = b; ?

bool isBoolean();
Returns true if T can be converted to boolean value.
final const nothrow Type nullAttributes();
Return a copy of this type with all attributes null-initialized. Useful for creating a type with different modifiers.
final void fixTo(Type t);
For our new type 'this', which is type-constructed from t, fill in the cto, ito, sto, scto, wto shortcuts.
final void check();
Look for bugs in constructing types.
final Type addSTC(StorageClass stc);
Apply STCxxxx bits to existing type. Use before semantic analysis is run.
final Type toBasetype();
If this is a shell around another type, get that other type.
MATCH implicitConvTo(Type to);
Determine if 'this' can be implicitly converted to type 'to'.
MATCH.nomatch, MATCH.convert, MATCH.constant, MATCH.exact
MATCH constConv(Type to);
Determine if converting 'this' to 'to' is an identity operation, a conversion to const operation, or the types aren't the same.
MATCH.exact 'this' == 'to' MATCH.constant 'to' is const MATCH.nomatch conversion to mutable or invariant
MOD deduceWild(Type t, bool isRef);
Compute MOD bits matching this argument type to wild parameter type.
Type t corresponding parameter type
bool isRef parameter is ref or out
MOD bits
structalign_t alignment();
Return alignment to use for this type.
Expression defaultInitLiteral(const ref Loc loc);
Use when we prefer the default initializer to be a literal, rather than a global immutable variable.
const int hasWild();
Return !=0 if the type or any of its subtypes is wild.
bool hasVoidInitPointers();
Detect if type has pointer fields that are initialized to void. Local stack variables with such void fields can remain uninitialized, leading to pointer bugs.
true if so
bool hasUnsafeBitpatterns();
Detect if this is an unsafe type because of the presence of @system members
true if so
bool hasInvariant();
true if type has any invariants
Type nextOf();
If this is a type of something, return that something.
final Type baseElemOf();
If this is a type of static array, return its base element type.
final uint numberOfElems(const ref Loc loc);
Compute number of elements for a (possibly multidimensional) static array, or 1 for other types.
Loc loc for error message
number of elements, uint.max on overflow
final uinteger_t sizemask();
Return the mask that an integral type will fit into.
bool needsDestruction();
true if when type goes out of scope, it needs a destructor applied. Only applies to value types, not ref types.
bool needsCopyOrPostblit();
true if when type is copied, it needs a copy constructor or postblit applied. Only applies to value types, not ref types.
bool needsNested();
final inout pure nothrow @nogc inout(TypeFunction) isPtrToFunction();
Is this type a pointer to a function?
the function type if it is
final inout pure nothrow @nogc inout(TypeFunction) isFunction_Delegate_PtrToFunction();
Is this type a function, delegate, or pointer to a function?
the function type if it is
class TypeError: dmd.mtype.Type;
abstract class TypeNext: dmd.mtype.Type;
final @safe Type nextOf();
For TypeFunction, nextOf() can return NULL if the function return type is meant to be inferred, and semantic() hasn't yet ben run on the function. After semantic(), it must no longer be NULL.
class TypeBasic: dmd.mtype.Type;
class TypeVector: dmd.mtype.Type;
The basetype must be one of: byte[16],ubyte[16],short[8],ushort[8],int[4],uint[4],long[2],ulong[2],float[4],double[2] For AVX: byte[32],ubyte[32],short[16],ushort[16],int[8],uint[8],long[4],ulong[4],float[8],double[4]
abstract class TypeArray: dmd.mtype.TypeNext;
class TypeSArray: dmd.mtype.TypeArray;
Static array, one with a fixed dimension
bool isIncomplete();
C11 incomplete array type
true if incomplete type
bool needsNested();
class TypeDArray: dmd.mtype.TypeArray;
Dynamic array, no dimension
class TypeAArray: dmd.mtype.TypeArray;
class TypePointer: dmd.mtype.TypeNext;
class TypeReference: dmd.mtype.TypeNext;
class TypeFunction: dmd.mtype.TypeNext;
bool hasLazyParameters();
Return true if there are lazy parameters.
const pure nothrow @safe bool isDstyleVariadic();
Check for extern (D) U func(T t, ...) variadic function type, which has _arguments[] added as the first argument.
true if D-style variadic
Expressions* resolveNamedArgs(ArgumentList argumentList, const(char)** pMessage);
Convert an argumentList, which may contain named arguments, into a list of arguments in the order of the parameter list.
ArgumentList argumentList array of function arguments
const(char)** pMessage address to store error message, or null
re-ordered argument list, or null on error
MATCH constConv(Type to);
Extends TypeNext.constConv by also checking for matching attributes
const pure nothrow @nogc @safe bool iswild();
true the function is isInOutQual or isInOutParam ,false otherwise.
const pure nothrow @nogc @safe bool attributesEqual(scope const TypeFunction other, bool trustSystemEqualsDefault = true);
whether this function type has the same attributes (@safe,...) as other
class TypeDelegate: dmd.mtype.TypeNext;
class TypeTraits: dmd.mtype.Type;
This is a shell containing a TraitsExp that can be either resolved to a type or to a symbol.
The point is to allow AliasDeclarationY to use __traits(), see
TraitsExp exp;
The expression to resolve as type or symbol.
RootObject obj;
Cached type/symbol after semantic analysis.
class TypeMixin: dmd.mtype.Type;
Implements mixin types.
Semantic analysis will convert it to a real type.
abstract class TypeQualified: dmd.mtype.Type;
class TypeIdentifier: dmd.mtype.TypeQualified;
class TypeInstance: dmd.mtype.TypeQualified;
Similar to TypeIdentifier, but with a TemplateInstance as the root
class TypeTypeof: dmd.mtype.TypeQualified;
class TypeReturn: dmd.mtype.TypeQualified;
class TypeStruct: dmd.mtype.Type;
Expression defaultInitLiteral(const ref Loc loc);
Use when we prefer the default initializer to be a literal, rather than a global immutable variable.
class TypeEnum: dmd.mtype.Type;
class TypeClass: dmd.mtype.Type;
class TypeTuple: dmd.mtype.Type;
this(Expressions* exps);
Form TypeTuple from the types of the expressions. Assume exps[] is already tuple expanded.
@safe this();
Type tuple with 0, 1 or 2 types in it.
class TypeSlice: dmd.mtype.TypeNext;
This is so we can slice a TypeTuple
class TypeNull: dmd.mtype.Type;
class TypeNoreturn: dmd.mtype.Type;
class TypeTag: dmd.mtype.Type;
Unlike D, C can declare/define struct/union/enum tag names inside Declarators, instead of separately as in D. The order these appear in the symbol table must be in lexical order. There isn't enough info at the parsing stage to determine if it's a declaration or a reference to an existing name, so this Type collects the necessary info and defers it to semantic().
Loc loc;
location of declaration
TOK tok;
TOK.struct_, TOK.union_, TOK.enum_
structalign_t packalign;
alignment of struct/union fields
Identifier id;
tag name identifier
Type base;
base type for enums otherwise null
Dsymbols* members;
members of struct, null if none
Type resolved;
type after semantic() in case there are more others
MOD mod;
pointing to this instance, which can happen with struct S { int a; } s1, *s2;
modifiers to apply after type is resolved (only MODFlags.const_ at the moment)
struct ParameterList;
Represents a function's formal parameters + variadics info. Length, indexing and iteration are based on a depth-first tuple expansion.
Parameters* parameters;
The raw (unexpanded) formal parameters, possibly containing tuples.
size_t length();
Returns the number of expanded parameters. Complexity: O(N).
Parameter opIndex(size_t i);
Returns the expanded parameter at the given index, or null if out of bounds. Complexity: O(i).
int opApply(scope Parameter.ForeachDg dg);
Iterates over the expanded parameters. Complexity: O(N). Prefer this to avoid the O(N + N^2/2) complexity of calculating length and calling N times opIndex.
int opApply(scope Parameter.SemanticForeachDg dg);
Iterates over the expanded parameters, matching them with the unexpanded ones, for semantic processing
const bool opEquals(ref scope ParameterList other);
Compares this to another ParameterList (and expands tuples if necessary)
bool hasDefaultArgs();
true if any parameter has a default argument
class Parameter: dmd.ast_node.ASTNode;
Type isLazyArray();
Determine if parameter is a lazy array of delegates. If so, return the return type of those delegates. If not, return NULL.
Returns T if the type is one of the following forms: T delegate()[] T delegate()dim
const pure nothrow @nogc @safe bool isLazy();
Whether the function parameter is lazy
const pure nothrow @nogc @safe bool isReference();
Whether the function parameter is a reference (out / ref)
static size_t dim(Parameters* parameters);
Determine number of arguments, folding in tuples.
static Parameter getNth(Parameters* parameters, size_t nth);
Get nth Parameter, folding in tuples.
Since parameters can include tuples, which would increase its length, this function allows to get the nth parameter as if all tuples transitively contained in parameters were flattened.
Parameters* parameters Array of Parameter to iterate over
size_t nth Index of the desired parameter.
The parameter at index nth (taking tuples into account), or null if out of bound.
alias ForeachDg = int delegate(ulong paramidx, Parameter param);
Type of delegate when iterating solely on the parameters
alias SemanticForeachDg = int delegate(ulong oidx, Parameter oparam, ulong eidx, Parameter eparam);
Type of delegate when iterating on both the original set of parameters, and the type tuple. Useful for semantic analysis. 'o' stands for 'original' and 'e' stands for 'expanded'.
static int _foreach(Parameters* parameters, scope ForeachDg dg);

static int _foreach(Parameters* parameters, scope SemanticForeachDg dg);
Expands tuples in args in depth first order. Calls dg(void *ctx, size_t argidx, Parameter *arg) for each Parameter. If dg returns !=0, stops and returns that value else returns 0. Use this function to avoid the O(N + N^2/2) complexity of calculating dim and calling N times getNth.
const pure nothrow @nogc @safe bool isCovariant(bool returnByRef, const Parameter p);
Compute covariance of parameters this and p as determined by the storage classes of both.
bool returnByRef true if the function returns by ref
Parameter p Parameter to compare with
true = this can be used in place of p false = nope
const(char*)[2] toAutoQualChars(Type t1, Type t2);
For printing two types with qualification when necessary.
Type t1 The first type to receive the type name for
Type t2 The second type to receive the type name for
The fully-qualified names of both types if the two type names are not the same, or the unqualified names of both types if the two type names are the same.
void modifiersApply(const TypeFunction tf, void delegate(string) dg);
For each active modifier (MODFlags.const_, MODFlags.immutable_, etc) call fp with a void* for the work param and a string representation of the attribute.
void attributesApply(const TypeFunction tf, void delegate(string) dg, TRUSTformat trustFormat = TRUSTformatDefault);
For each active attribute (ref/const/nogc/etc) call fp with a void* for the work param and a string representation of the attribute.
AggregateDeclaration isAggregate(Type t);
If the type is a class or struct, returns the symbol for it, else null.
bool isIndexableNonAggregate(Type t);
Determine if type t can be indexed or sliced given that it is not an aggregate with operator overloads.
Type t type to check
true if an expression of type t can be e1 in an array expression
pure nothrow @nogc @safe ScopeRef buildScopeRef(StorageClass stc);
Computes how a parameter may be returned. Shrinking the representation is necessary because StorageClass is so wide
StorageClass stc storage class of parameter
value from enum ScopeRef
enum ScopeRef: int;
Classification of 'scope-return-ref' possibilities
pure nothrow @nogc @safe const(char)* ScopeRefToChars(ScopeRef sr);
Give us a nice string for debugging purposes.
ScopeRef sr value
corresponding string
TypeVector toBooleanVector(TypeVector tv);
Creates an appropriate vector type for tv that will hold one boolean result for each element of the vector type. The result of vector comparisons is a single or doubleword mask of all 1s (comparison true) or all 0s (comparison false). This SIMD mask type does not have an equivalent D type, however its closest equivalent would be an integer vector of the same unit size and length.
TypeVector tv The TypeVector to build a vector from.
A vector type suitable for the result of a vector comparison operation.
Result VisitType(Result)(Type t);
Dispatch to function based on static type of Type.
pure @safe string visitTYCase(string handler);
CTFE-only helper function for VisitInitializer.
string handler string for the name of the visit handler
boilerplate code for a case
TypeIdentifier getThrowable();
TypeIdentifier corresponding to object.Throwable
TypeIdentifier getException();
TypeIdentifier corresponding to object.Exception