Menu

- Learn
- Documentation
  - Language Reference
  - Library Reference
  - Command-line Reference
  - Feature Overview
  - Articles
- Downloads
- Packages
- Community
  - Blog
  - Orgs using D
  - Twitter
  - Calendar
  - Forums
  - IRC
  - Community Discord
  - Wiki
  - GitHub
  - Issues
  - Get involved
  - Contributors
  - Foundation
  - Security Team
  - Donate
  - Sponsors
- Resources
  - Tour
  - Books
  - Tutorials
  - Tools
  - Editors
  - IDEs
  - run.dlang.io
  - Visual D
  - Acknowledgments
  - D Style
  - Glossary
  - Sitemap

Search
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:
Walter Bright
License:
Boost License 1.0

Source mtype.d

Documentation https://dlang.org/phobos/dmd_mtype.html

Coverage https://codecov.io/gh/dlang/dmd/src/master/src/dmd/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`);
  Returns:
  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
pure nothrow @nogc @safe bool `isSomeChar`(TY `ty`);
  Returns true if ty is char, wchar, or dchar
enum `DotExpFlag`: int;
  dotExp() bit flags
enum `VarArg`: ubyte;
  Variadic argument lists https://dlang.org/spec/function.html#variadic
  `none`
    fixed number of arguments
  `variadic`
    (T t, ...) can be C-style (core.stdc.stdarg) or D-style (core.vararg)
  `typesafe`
    (T t ...) typesafe https://dlang.org/spec/function.html#typesafe_variadic_functions
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.
    Parameters:

    Type `t` | type 'this' is covariant with
    StorageClass* `pstc` | if not null, store STCxxxx which would make it covariant
    bool `fix17349` | enable fix https://issues.dlang.org/show_bug.cgi?id=17349

    Returns:
    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.
  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`(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.
    Returns:
    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.
    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`(ref const 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

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.
    Returns:
    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.
    Parameters:

    Type `tthis` | type of this parameter, null if none
    Parameter `p` | parameter to this function

    Returns:
    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.)
    Parameters:

    Type `tthis` | type of this parameter, null if none
    Parameter `p` | parameter to this function

    Returns:
    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.
    Parameters:

    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

    Returns:
    MATCHxxxx
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.
  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;
struct `ParameterList`;
  Encapsulate Parameters* so .length and [i] can be used on it. https://dlang.org/spec/function.html#ParameterList
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.
    Returns:
    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.
    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

Copyright © 1999-2020 by the D Language Foundation | Page generated by Ddoc on Tue Jul 7 12:26:08 2020