# dmd.typesem

Semantic analysis for D types.

#### Authors

Walter Bright

#### License

Boost License 1.0

Source: typesem.d

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

Coverage: https://codecov.io/gh/dlang/dmd/src/master/src/dmd/typesem.d

- `typeToExpression`

  #### Declaration

  `Expression `typeToExpression`(Type `t`);`

  We've mistakenly parsed ``t`` as a type. Redo ``t`` as an Expression only if there are no type modifiers.

  #### Parameters

  `Type `t`` | mistaken type

  #### Return Value

  `t` redone as Expression, `null` if cannot

- `typeSemantic`

  #### Declaration

  `Type `typeSemantic`(Type `type`, ref const Loc `loc`, Scope* `sc`);`

  Perform semantic analysis on a `type`.

  #### Parameters

  `Type `type`` | Type AST node
  `Loc `loc`` | the location of the `type`
  `Scope* `sc`` | context

  #### Return Value

  `Type` with completed semantic analysis, `Terror` if errors were encountered

- `compileTypeMixin`

  #### Declaration

  `RootObject `compileTypeMixin`(TypeMixin `tm`, Loc `loc`, Scope* `sc`);`

  Compile the MixinType, returning the type or expression AST.

  #### Discussion

  Doesn't run semantic() on the returned object.

  #### Parameters

  `TypeMixin `tm`` | mixin to compile as a type or expression
  `Loc `loc`` | location for error messages
  `Scope* `sc`` | context

  Return: `null` if error, else RootObject AST as parsed

- `merge`

  #### Declaration

  `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.

  #### Parameters

  `Type `type`` | Type to check against existing types

  #### Return Value

  the `type` that was merged

- `getProperty`

  #### Declaration

  `Expression `getProperty`(Type `t`, Scope* `scope_`, ref const Loc `loc`, Identifier `ident`, int `flag`);`

  Calculate built-in properties which just the type is necessary.

  #### Parameters

  `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.

  #### Return Value

  expression representing the property, or `null` if not a property and (`flag` & 1)

- `resolve`

  #### Declaration

  `void `resolve`(Type `mt`, ref const Loc `loc`, Scope* `sc`, Expression* `pe`, Type* `pt`, Dsymbol* `ps`, bool `intypeid` = false);`

  Resolve type '`mt`' to either type, symbol, or expression. If errors happened, resolved to Type.terror.

  #### Parameters

  `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

- `dotExp`

  #### Declaration

  `Expression `dotExp`(Type `mt`, Scope* `sc`, Expression `e`, Identifier `ident`, int `flag`);`

  Access the members of the object `e`. This type is same as `e`.type.

  #### Parameters

  `Type `mt`` | type for which the dot expression is used
  `Scope* `sc`` | instantiating scope
  `Expression `e`` | expression to convert
  `Identifier `ident`` | identifier being used
  `int `flag`` | DotExpFlag bit flags

  #### Return Value

  resulting expression with `e`.`ident` resolved

- `defaultInit`

  #### Declaration

  `Expression `defaultInit`(Type `mt`, ref const Loc `loc`);`

  Get the the default initialization expression for a type.

  #### Parameters

  `Type `mt`` | the type for which the init expression is returned
  `Loc `loc`` | the location where the expression needs to be evaluated

  #### Return Value

  The initialization expression for the type.