# dmd.opover

Handles operator overloading.

Specification: Operator Overloading

#### Authors

Walter Bright

#### License

Boost License 1.0

Source: opover.d

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

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

- `isCommutative`

  #### Declaration

  `bool `isCommutative`(TOK `op`);`

  Determine if operands of binary `op` can be reversed to fit operator overload.

- `opToArg`

  #### Declaration

  `Objects* `opToArg`(Scope* `sc`, TOK `op`);`

  Helper function to turn operator into template argument list

- `op_overload`

  #### Declaration

  `Expression `op_overload`(Expression `e`, Scope* `sc`, TOK* `pop` = null);`

  Operator overload. Check for operator overload, if so, replace with function call.

  #### Parameters

  `Expression `e`` | expression with operator
  `Scope* `sc`` | context
  `TOK* `pop`` | if not `null`, is set to the operator that was actually overloaded, which may not be ``e`.op`. Happens when operands are reversed to match an overload

  #### Return Value

  `null` if not an operator overload, otherwise the lowered expression

- `build_overload`

  #### Declaration

  `Expression `build_overload`(const ref Loc `loc`, Scope* `sc`, Expression `ethis`, Expression `earg`, Dsymbol `d`);`

  Utility to build a function call out of this reference and argument.

- `search_function`

  #### Declaration

  `Dsymbol `search_function`(ScopeDsymbol `ad`, Identifier `funcid`);`

  Search for function `funcid` in aggregate `ad`.

- `inferForeachAggregate`

  #### Declaration

  `bool `inferForeachAggregate`(Scope* `sc`, bool `isForeach`, ref Expression `feaggr`, out Dsymbol `sapply`);`

  Figure out what is being foreach'd over by looking at the ForeachAggregate.

  #### Parameters

  `Scope* `sc`` | context
  `bool `isForeach`` | `true` for foreach, `false` for foreach_reverse
  `Expression `feaggr`` | ForeachAggregate
  `Dsymbol `sapply`` | set to function opApply/opApplyReverse, or delegate, or `null`. Overload resolution is not done.

  #### Return Value

  `true` if successfully figured it out; `feaggr` updated with semantic analysis. `false` for failed, which is an error.

- `inferApplyArgTypes`

  #### Declaration

  `bool `inferApplyArgTypes`(ForeachStatement `fes`, Scope* `sc`, ref Dsymbol `sapply`);`

  Given array of foreach parameters and an aggregate type, find best opApply overload, if any of the parameter types are missing, attempt to infer them from the aggregate type.

  #### Parameters

  `ForeachStatement `fes`` | the foreach statement
  `Scope* `sc`` | context
  `Dsymbol `sapply`` | `null` or opApply or delegate

  #### Return Value

  `false` for errors