Display the source code in dmd/mtype.d from which this page was generated on github.

If you spot a problem with this page, click here to create a Bugzilla issue.

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 local clone.

Class `dmd.mtype.TypeFunction`


						
				class TypeFunction
				
  : TypeNext
				;

Methods

Name	Description
`callMatch`	'args' are being matched to function 'this' Determine match level.
`hasLazyParameters`	Return true if there are lazy parameters.
`parameterEscapes`	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.
`parameterStorageClass`	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.)
`purityLevel`	Set 'purity' field of 'this'. Do this lazily, as the parameter types might be forward referenced.
`addMod`	Add MODxxxx bits to existing type. We're adding, not replacing, so adding const to a shared type => "shared const"
`addSTC`	Apply STCxxxx bits to existing type. Use before semantic analysis is run.
`addStorageClass`	Add storage class modifiers to type.
`alignment`	Return alignment to use for this type.
`baseElemOf`	If this is a type of static array, return its base element type.
`castMod`	Apply MODxxxx bits to existing type.
`check`	Look for bugs in constructing types.
`checkComplexTransition`
`checkDeprecated`	Check type to see if it is based on a deprecated symbol.
`constConv`	Determine if converting 'this' to 'to' is an identity operation, a conversion to const operation, or the types aren't the same.
`constOf`	Convert to 'const'.
`covariant`	Covariant means that 'this' can substitute for 't', i.e. a pure function is a match for an impure type.
`deduceWild`	Compute MOD bits matching `this` argument type to wild parameter type.
`defaultInitLiteral`	Use when we prefer the default initializer to be a literal, rather than a global immutable variable.
`factory`	Create instance of class specified by the fully qualified name classname. The class must either have no constructors or have a default constructor.
`fixTo`	For our new type 'this', which is type-constructed from t, fill in the cto, ito, sto, scto, wto shortcuts.
`hasPointers`	Return !=0 if type has pointers that need to be scanned by the GC during a collection cycle.
`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.
`hasWild`	Return !=0 if the type or any of its subtypes is wild.
`immutableOf`	Convert to 'immutable'.
`implicitConvTo`	Determine if 'this' can be implicitly converted to type 'to'.
`isAssignable`	When T is mutable,
`isBoolean`	Returns true if T can be converted to boolean value.
`merge2`	This version does a merge even if the deco is already computed. Necessary for types that have a deco, but are not merged.
`modToBuffer`	Store this type's modifier name into buf.
`modToChars`	Return this type's modifier name.
`mutableOf`	Make type mutable.
`needsDestruction`	true if when type goes out of scope, it needs a destructor applied. Only applies to value types, not ref types.
`needsNested`
`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.
`nullAttributes`	Return a copy of this type with all attributes null-initialized. Useful for creating a type with different modifiers.
`numberOfElems`	Compute number of elements for a (possibly multidimensional) static array, or 1 for other types.
`opCmp`	Compare with another Object obj.
`opEquals`	Test whether `this` is equal to `o`. The default implementation only compares by identity (using the `is` operator). Generally, overrides for `opEquals` should attempt to compare objects by their contents.
`sizemask`	Return the mask that an integral type will fit into.
`toBasetype`	If this is a shell around another type, get that other type.
`toChars`	For pretty-printing a type.
`toHash`	Compute hash function for Object.
`toHeadMutable`	Return type with the top level of it being mutable.
`toPrettyChars`	For pretty-printing a type.
`toString`
`toString`	Convert Object to a human readable string.
`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
`wildOf`	Convert to 'wild'.

Authors

Walter Bright

License

Boost License 1.0