# dmd.dcast

Semantic analysis for cast-expressions.

#### Authors

Walter Bright

#### License

Boost License 1.0

Source: dcast.d

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

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

- `implicitCastTo`

  #### Declaration

  `Expression `implicitCastTo`(Expression `e`, Scope* `sc`, Type `t`);`

  Attempt to implicitly cast the expression into type ``t``.

  #### Discussion

  This routine will change ``e``. To check the matching level, use `implicitConvTo`.

  #### Parameters

  `Expression `e`` | Expression that is to be casted
  `Scope* `sc`` | Current scope
  `Type `t`` | Expected resulting type

  #### Return Value

  The resulting casted expression (mutating ``e``), or `ErrorExp` if such an implicit conversion is not possible.

- `implicitConvTo`

  #### Declaration

  `MATCH `implicitConvTo`(Expression `e`, Type `t`);`

  Checks whether or not an expression can be implicitly converted to type ``t``.

  #### Discussion

  Unlike `implicitCastTo`, this routine does not perform the actual cast, but only checks up to what `MATCH` level the conversion would be possible.

  #### Parameters

  `Expression `e`` | Expression that is to be casted
  `Type `t`` | Expected resulting type

  #### Return Value

  The `MATCH` level between ``e`.type` and ``t``.

- `castTo`

  #### Declaration

  `Expression `castTo`(Expression `e`, Scope* `sc`, Type `t`, Type `att` = null);`

  Do an explicit cast. Assume that the expression ``e`` does not have any indirections. (Parameter '`att`' is used to stop 'alias this' recursion)

- `inferType`

  #### Declaration

  `Expression `inferType`(Expression `e`, Type `t`, int `flag` = 0);`

  Set type inference target `t` Target type `flag` 1: don'`t` put an error when inference fails

- `scaleFactor`

  #### Declaration

  `Expression `scaleFactor`(BinExp `be`, Scope* `sc`);`

  Scale addition/subtraction to/from pointer.

- `typeMerge`

  #### Declaration

  `Type `typeMerge`(Scope* `sc`, TOK `op`, ref Expression `pe1`, ref Expression `pe2`);`

  Merge types of `e1` and `e2` into a common subset

  #### Discussion

  Parameters `e1` and `e2` will be rewritten in place as needed.

  #### Parameters

  `Scope* `sc`` | Current scope
  `TOK `op`` | Operator such as `e1 `op` e2`. In practice, either TOK.question or one of the binary operator.
  `Expression `pe1`` | The LHS of the operation, will be rewritten
  `Expression `pe2`` | The RHS of the operation, will be rewritten

  #### Return Value

  The resulting type in case of success, `null` in case of error

- `typeCombine`

  #### Declaration

  `Expression `typeCombine`(BinExp `be`, Scope* `sc`);`

  Bring leaves to common type.

  #### Return Value

  `null` on success, ErrorExp if error occurs

- `integralPromotions`

  #### Declaration

  `Expression `integralPromotions`(Expression `e`, Scope* `sc`);`

  Do integral promotions (convertchk). Don't convert to

- `fix16997`

  #### Declaration

  `void `fix16997`(Scope* `sc`, UnaExp `ue`);`

  This provides a transition from the non-promoting behavior of unary + - ~ to the C-like integral promotion behavior.

  #### Parameters

  `Scope* `sc`` | context
  `UnaExp `ue`` | NegExp, UAddExp, or ComExp which is revised per rules

  References: https://issues.dlang.org/show_bug.cgi?id=16997

- `arrayTypeCompatibleWithoutCasting`

  #### Declaration

  `bool `arrayTypeCompatibleWithoutCasting`(Type `t1`, Type `t2`);`

  See if both types are arrays that can be compared for equality without any casting. Return `true` if so. This is to enable comparing things like an immutable array with a mutable one.

- `getIntRange`

  #### Declaration

  `IntRange `getIntRange`(Expression `e`);`