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.

dmd.mtype

Defines a D type.
Authors:

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);
Returns:
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
int mutabilityOfType(bool isref, Type t);
Determine mutability of indirections in (ref) t.
Returns:
When the type has any mutable indirections, returns 0. When all indirections are immutable, returns 2. Otherwise, when the type has const/inout indirections, returns 1.
Parameters:
bool isref if true, check ref t; otherwise, check just t
Type t the type that is being checked
enum DotExpFlag: int;
dotExp() bit flags
enum Covariant: int;
Result of a check whether two types are covariant
distinct
types are distinct
yes
types are covariant
no
arguments match as far as overloading goes, but types are not covariant
fwdref
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 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(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 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.
final bool checkAliasThisRec();
Check whether this type has endless alias this recursion.
Returns:
true if this type has an alias this that can be implicitly converted back to this type itself.
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'.
Returns:
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.
Returns:
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.
Parameters:
Type t corresponding parameter type
bool isRef parameter is ref or out
Returns:
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(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 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.
Returns:
true if so
bool hasSystemFields();
Detect if this is an unsafe type because of the presence of @system members
Returns:
true if so
bool hasInvariant();
Returns:
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.
Parameters:
Loc loc for error message
Returns:
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 bool checkComplexTransition(const ref Loc loc, Scope* sc);
https://issues.dlang.org/show_bug.cgi?id=14488 Check if the inner most base type is complex or imaginary. Should only give alerts when set to emit transitional messages.
Parameters:
Loc loc The source location.
Scope* sc scope of the type
final inout pure nothrow @nogc inout(TypeFunction) isPtrToFunction();
Is this type a pointer to a function?
Returns:
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?
Returns:
the function type if it is
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 isIncomplete();
C11 6.7.6.2-4 incomplete array type
Returns:
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;
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.
Returns:
true if D-style variadic
StorageClass parameterStorageClass(Type tthis, Parameter p, VarDeclarations* outerVars = null, bool indirect = false);
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.)
Parameters:
Type tthis type of this parameter, null if none
Parameter p parameter to this function
VarDeclarations* outerVars context variables p could escape into, if any
bool indirect is this for an indirect or virtual function call?
Returns:
storage class with STC.scope_ or STC.return_ OR'd in
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.
Parameters:
ArgumentList argumentList array of function arguments
const(char)** pMessage address to store error message, or null
Returns:
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();
Returns:
true the function is isInOutQual or isInOutParam ,false otherwise.
const pure nothrow @nogc @safe bool attributesEqual(scope const TypeFunction other, bool trustSystemEqualsDefault = true);
Returns:
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 https://issues.dlang.org/show_bug.cgi?id=7804.
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;
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(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. https://dlang.org/spec/function.html#ParameterList
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();
Returns:
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();
Returns:
Whether the function parameter is lazy
const pure nothrow @nogc @safe bool isReference();
Returns:
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* parameters Array of Parameter to iterate over
size_t nth Index of the desired parameter.
Returns:
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.
Parameters:
bool returnByRef true if the function returns by ref
Parameter p Parameter to compare with
Returns:
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.
Parameters:
Type t1 The first type to receive the type name for
Type t2 The second type to receive the type name for
Returns:
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.
Parameters:
Type t type to check
Returns:
true if an expression of type t can be e1 in an array expression
bool isCopyable(Type t);
Determine if type t is copyable.
Parameters:
Type t type to check
Returns:
true if we can copy it
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
Parameters:
StorageClass stc storage class of parameter
Returns:
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.
Parameters:
ScopeRef sr value
Returns:
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.
Parameters:
TypeVector tv The TypeVector to build a vector from.
Returns:
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.
Parameters:
string handler string for the name of the visit handler
Returns:
boilerplate code for a case
TypeIdentifier getThrowable();
Returns:
TypeIdentifier corresponding to object.Throwable
TypeIdentifier getException();
Returns:
TypeIdentifier corresponding to object.Exception
bool isRecursiveAliasThis(ref Type att, Type t);
Check and set 'att' if 't' is a recursive 'alias this' type
The goal is to prevent endless loops when there is a cycle in the alias this chain. Since there is no multiple alias this, the chain either ends in a leaf, or it loops back on itself as some point.

Example S0 -> (S1 -> S2 -> S3 -> S1)

S0 is not a recursive alias this, so this returns false, and a rewrite to S1 can be tried. S1 is a recursive alias this type, but since att is initialized to null, this still returns false, but att1 is set to S1. A rewrite to S2 and S3 can be tried, but when we want to try a rewrite to S1 again, we notice att == t, so we're back at the start of the loop, and this returns true.

Parameters:
Type att type reference used to detect recursion. Should be initialized to null.
Type t type of 'alias this' rewrite to attempt
Returns:
false if the rewrite is safe, true if it would loop back around