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.


Semantic analysis for D types.

Source typesem.d

bool isCopyable(Type t);
Determine if type t is copyable.
Type t type to check
true if we can copy it
int mutabilityOfType(bool isref, Type t);
Determine mutability of indirections in (ref) t.
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.
bool isref if true, check ref t; otherwise, check just t
Type t the type that is being checked
void purityLevel(TypeFunction typeFunction);
Set 'purity' field of 'typeFunction'. Do this lazily, as the parameter types might be forward referenced.
Expression typeToExpression(Type t);
We've mistakenly parsed t as a type. Redo t as an Expression only if there are no type modifiers.
Type t mistaken type
t redone as Expression, null if cannot
bool checkComplexTransition(Type type, const ref 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.
Type type type to check
Loc loc The source location.
Scope* sc scope of the type
MATCH callMatch(TypeFunction tf, Type tthis, ArgumentList argumentList, int flag = 0, void delegate(const(char)*) scope errorHelper = null, Scope* sc = null);
'args' are being matched to function type 'tf' Determine match level.
TypeFunction tf function type
Type tthis type of this pointer, null if not member function
ArgumentList argumentList arguments to function call
int flag 1: performing a partial ordering match
void delegate(const(char)*) scope errorHelper delegate to call for error messages
Scope* sc context
bool hasPointers(Type t);
Return !=0 if type has pointers that need to be scanned by the GC during a collection cycle.
Type typeSemantic(Type type, const ref Loc loc, Scope* sc);
Perform semantic analysis on a type.
Type type Type AST node
Loc loc the location of the type
Scope* sc context
Type with completed semantic analysis, Terror if errors were encountered
Type merge(Type type);
If an identical type to type is in type.stringtable, return the latter one. Otherwise, add it to type.stringtable. Some types don't get merged and are returned as-is.
Type type Type to check against existing types
the type that was merged
Type merge2(Type type);
This version does a merge even if the deco is already computed. Necessary for types that have a deco, but are not merged.
Expression getProperty(Type t, Scope* scope_, const ref Loc loc, Identifier ident, int flag, Expression src = null);
Calculate built-in properties which just the type is necessary.
Type t the type for which the property is calculated
Scope* scope_ the scope from which the property is being accessed. Used for visibility checks only.
Loc loc the location where the property is encountered
Identifier ident the identifier of the property
int flag if flag & 1, don't report "not a property" error and just return NULL.
Expression src expression for type t or null.
expression representing the property, or null if not a property and (flag & 1)
void resolve(Type mt, const ref Loc loc, Scope* sc, out Expression pe, out Type pt, out Dsymbol ps, bool intypeid = false);
Resolve type 'mt' to either type, symbol, or expression. If errors happened, resolved to Type.terror.
Type mt type to be resolved
Loc loc the location where the type is encountered
Scope* sc the scope of the type
Expression pe is set if t is an expression
Type pt is set if t is a type
Dsymbol ps is set if t is a symbol
bool intypeid true if in type id
Expression dotExp(Type mt, Scope* sc, Expression e, Identifier ident, DotExpFlag flag);
Access the members of the object e. This type is same as e.type.
Type mt type for which the dot expression is used
Scope* sc instantiating scope
Expression e expression to convert
Identifier ident identifier being used
DotExpFlag flag DotExpFlag bit flags
resulting expression with e.ident resolved
Expression defaultInit(Type mt, const ref Loc loc, const bool isCfile = false);
Get the default initialization expression for a type.
Type mt the type for which the init expression is returned
Loc loc the location where the expression needs to be evaluated
bool isCfile default initializers are different with C
The initialization expression for the type.
Type addStorageClass(Type type, StorageClass stc);
Add storage class modifiers to type.
Type getComplexLibraryType(const ref Loc loc, Scope* sc, TY ty);
Extract complex type from core.stdc.config
Loc loc for error messages
Scope* sc context
TY ty a complex or imaginary type
Complex!float, Complex!double, Complex!real or null for error
Covariant covariant(Type src, Type t, StorageClass* pstc = null, bool cppCovariant = false);
Covariant means that 'src' can substitute for 't', i.e. a pure function is a match for an impure type.
Type src source type
Type t type 'src' is covariant with
StorageClass* pstc if not null, store STCxxxx which would make it covariant
bool cppCovariant true if extern(C++) function types should follow C++ covariant rules
An enum value of either Covariant.yes or a reason it's not covariant.
StorageClass parameterStorageClass(TypeFunction tf, 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.)
TypeFunction tf TypeFunction to use to get the signature from
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?
storage class with STC.scope_ or STC.return_ OR'd in
Type constOf(Type type);
Convert to 'const'.
Type immutableOf(Type type);
Convert to 'immutable'.
Type mutableOf(Type type);
Make type mutable.
Type unSharedOf(Type type);
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
Type wildOf(Type type);
Convert to 'wild'.
Type toHeadMutable(const Type t);
Return type with the top level of it being mutable.
Type t type for which the top level mutable version is being returned
type version with mutable top level
Type castMod(Type type, MOD mod);
Apply MODxxxx bits to existing type.
Type addMod(Type type, MOD mod);
Add MODxxxx bits to existing type. We're adding, not replacing, so adding const to a shared type => "shared const"
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.

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