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.


Compiler implementation of the D programming language.

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 void MODtoBuffer(OutBuffer* buf, MOD mod);
Store modifier name into buf.
pure nothrow const(char)* MODtoChars(MOD mod);

pure nothrow string MODtoString(MOD mod);
a human readable representation of mod, which is the token mod corresponds to
pure nothrow @nogc @safe StorageClass ModToStc(uint mod);
Convert MODxxxx to STCxxx
enum DotExpFlag: int;
dotExp() bit flags
enum VarArg: int;
fixed number of arguments
(T t, ...) can be C-style (core.stdc.stdarg) or D-style (core.vararg)
abstract class Type: dmd.ast_node.ASTNode;
final int covariant(Type t, StorageClass* pstc = null, bool fix17349 = true);
Covariant means that 'this' can substitute for 't', i.e. a pure function is a match for an impure type.
Type t type 'this' is covariant with
StorageClass* pstc if not null, store STCxxxx which would make it covariant
bool fix17349 enable fix
0 types are distinct 1 this is covariant with t 2 arguments match as far as overloading goes, but types are not covariant 3 cannot determine covariance because of forward references *pstc STCxxxx which would make it covariant
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 Type merge2();
This version does a merge even if the deco is already computed. Necessary for types that have a deco, but are not merged.
final const nothrow void modToBuffer(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.
void checkDeprecated(ref const Loc loc, Scope* sc);
Check type to see if it is based on a deprecated symbol.
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 Type constOf();
Convert to 'const'.
final Type immutableOf();
Convert to 'immutable'.
final Type mutableOf();
Make type mutable.
final Type unSharedOf();
Make type unshared. 0 => 0 const => const immutable => immutable shared => 0 shared const => const wild => wild wild const => wild const shared wild => wild shared wild const => wild const
final Type wildOf();
Convert to 'wild'.
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 castMod(MOD mod);
Apply MODxxxx bits to existing type.
final Type addMod(MOD mod);
Add MODxxxx bits to existing type. We're adding, not replacing, so adding const to a shared type => "shared const"
Type addStorageClass(StorageClass stc);
Add storage class modifiers to type.
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
inout inout(Type) toHeadMutable();
Return type with the top level of it being mutable.
structalign_t alignment();
Return alignment to use for this type.
Expression defaultInitLiteral(ref const 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 hasPointers();
Return !=0 if type has pointers that need to be scanned by the GC during a collection cycle.
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
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(ref const 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 needsNested();
final bool checkComplexTransition(ref const Loc loc, Scope* sc); Check if the inner most base type is complex or imaginary. Should only give alerts when set to emit transitional messages.
Loc loc The source location.
Scope* sc scope of the type
class TypeError: dmd.mtype.Type;
abstract class TypeNext: dmd.mtype.Type;
final 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 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;
void purityLevel();
Set 'purity' field of 'this'. Do this lazily, as the parameter types might be forward referenced.
bool hasLazyParameters();
Return true if there are lazy parameters.
const pure nothrow 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
bool parameterEscapes(Type tthis, Parameter p);
Examine function signature for parameter p and see if the value of p can 'escape' the scope of the function. This is useful to minimize the needed annotations for the parameters.
Type tthis type of this parameter, null if none
Parameter p parameter to this function
true if escapes via assignment to global or through a parameter
StorageClass parameterStorageClass(Type tthis, Parameter p);
Take the specified storage class for p, and use the function signature to infer whether STC.scope_ and STC.return_ should be OR'd in. (This will not affect the name mangling.)
Type tthis type of this parameter, null if none
Parameter p parameter to this function
storage class with STC.scope_ or STC.return_ OR'd in
MATCH callMatch(Type tthis, Expression[] args, int flag = 0, const(char)** pMessage = null, Scope* sc = null);
'args' are being matched to function 'this' Determine match level.
Type tthis type of this pointer, null if not member function
Expression[] args array of function arguments
int flag 1: performing a partial ordering match
const(char)** pMessage address to store error message, or null
Scope* sc context
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 issue 7804.
TraitsExp exp;
The expression to resolve as type or symbol.
Dsymbol sym;
After typeSemantic the symbol when exp doesn't represent a type.
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;
Dsymbol toDsymbol(Scope* sc);
See if type resolves to a symbol, if so, return that symbol.
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(ref const 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.
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;
struct ParameterList;
Encapsulate Parameters* so .length and [i] can be used on it.
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]
static size_t dim(Parameters* parameters);
Determine number of arguments, folding in tuples.
static Parameter getNth(Parameters* parameters, size_t nth, size_t* pn = null);
Get nth Parameter, folding in tuples.
Parameter* nth Parameter NULL not found, *pn gets incremented by the number of Parameters
static int _foreach(Parameters* parameters, scope ForeachDg dg, size_t* pn = null);
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 bool isCopyable(const Type t);
Determine if type t is copyable.
Type t type to check
true if we can copy it