dmd.mtype

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