A divide assignment operation (`/=`).

Right-associative.

Examples:

```width /= 2
amount /= exchangeRate
```
See also `QuotientOperation`
• `Anything`
• `Object`
• `Node`
• `Expression`
• `ValueExpression`
• `Operation`
• `BinaryOperation`
• `AssignmentOperation`
• `ArithmeticAssignmentOperation`
• `DivideAssignmentOperation`
• `DivideAssignmentOperation`
• `ArithmeticAssignmentOperation`
• `AssignmentOperation`
• `BinaryOperation`
• `Operation`
• `ValueExpression`
• `Expression`
• `Node`
• `Object`
• `Anything`

no subtypes hierarchy

 Initializer `DivideAssignmentOperation(ThenElseExpression target, AssigningExpression divisor)`Parameters: `target`The target expression and dividend / numerator. `divisor`The divisor / denominator.
 Attributes `children` `shared actual [ThenElseExpression, AssigningExpression] children`The child nodes of this node. Refines `AssignmentOperation.children` ultimately refines `Node.children` `divisor` `shared AssigningExpression divisor`The divisor / denominator. `hash` `shared actual Integer hash`The hash value of the value, which allows the value to be an element of a hash-based set or key of a hash-based map. Implementations must respect the constraint that: if `x==y` then `x.hash==y.hash`. Therefore, a class which refines `equals` must also refine `hash`. Because the `Integer` type is platform-dependent a compiler for a given platform is permitted to further manipulate the calculated hash for an object, and the resulting hash may differ between platforms. Refines `Object.hash` `leftOperand` `shared actual ThenElseExpression leftOperand`The target expression and dividend / numerator. See also `target`Refines `AssignmentOperation.leftOperand` ultimately refines `BinaryOperation.leftOperand` `operator` `shared actual String operator`The text of the operator. Refines `Operation.operator` `rightOperand` `shared actual AssigningExpression rightOperand`The divisor / denominator. See also `divisor`Refines `AssignmentOperation.rightOperand` ultimately refines `BinaryOperation.rightOperand` `target` `shared ThenElseExpression target`The target expression and dividend / numerator.
 Inherited Attributes Attributes inherited from: `AssignmentOperation` Attributes inherited from: `BinaryOperation` Attributes inherited from: `Expression``children` Attributes inherited from: `Node` Attributes inherited from: `Object``hash`, `string` Attributes inherited from: `Operation`
 Methods `copy` `shared DivideAssignmentOperation copy(ThenElseExpression leftOperand = ..., AssigningExpression rightOperand = ...)`Parameters: `leftOperand = this.leftOperand``rightOperand = this.rightOperand` `equals` `shared actual Boolean equals(Object that)`Determine if two values are equal. Implementations should respect the constraints that: if `x===y` then `x==y` (reflexivity), if `x==y` then `y==x` (symmetry), if `x==y` and `y==z` then `x==z` (transitivity). Furthermore it is recommended that implementations ensure that if `x==y` then `x` and `y` have the same concrete class. A class which explicitly refines `equals()` is said to support value equality, and the equality operator `==` is considered much more meaningful for such classes than for a class which simply inherits the default implementation of identity equality from `Identifiable`. Refines `Object.equals` `transform` `shared actual Result transform(Transformer transformer)`Transform this node with the given `transformer` by calling the appropriate `transformX` method on the transformer. If you have a `Node node` thatâ€™s actually an `LIdentifier` instance, then the runtime will call `LIdentifier.transform`; therefore, this method is by nature narrowing. This means that if `transformer` is a `NarrowingTransformer`, calling `node.transform(transformer)` is equivalent to calling `transformer.transformNode(node)`. On the other hand, if `transformer` is a `WideningTransformer`, then the two operations are very different. Refines `Node.transform` `visit` `shared actual void visit(Visitor visitor)`Visit this node with the given `visitor`. Calls the appropriate `visitX` method on the visitor. Refines `Node.visit`
 Inherited Methods Methods inherited from: `Node` Methods inherited from: `Object``equals`