Why isn't there a .= operator? (or ->= etc) Considering how often we do:

variable = variable + another;
variable = variable - another;
variable = variable * another;
variable = variable / another;
variable = variable &amp; another;
variable = variable | another;
variable = variable ^ another;


we then made the following language shortcuts:

variable += another;
variable -= another;
variable *= another;
variable /= another;
variable &amp;= another;
variable |= another;
variable ^= another;


so, then, considering how often we do this:

variable = variable.different();
// or variable = variable-&gt;different();
// or variable = variable::different();


(for instance, stringVar = stringVar.toUpperCase()), why isn't there one of these?

variable .= different();
// or variable -&gt;= different();
// or variable ::= different();


is it a parsing issue? Would it be too hard? Or is there some obvious thing I don't see here?

I'm not asking for opinions, here.
I want to know if there's any documented, historic, technical, or other verifiable reasons for why there is no such operator.
IMO, the biggest reason is that identifiers are not first class values in programming languages and "." is not a real operator like + or - are. For example, you can't convert

var foo = variable.bar()


into

var name = bar
var foo = variable.name()


The same way you can convert

var foo = 1 + 10


into

var x = 10
var foo = 1 + x


In more technical terms, in most languages x + y is an expression, while x, x.y and x[i] are identifiers. 

Summing up, when using your hypothetical .=, the right hand side needs to be interpreted as a field name, not an expression. This leads to unintuitive results - the following two lines look very similar but do wildly different things.

x += bar() // calls the bar() global function and add its value to x
y .= bar() // calls y's bar() method, and sets `y` to its result.




Additionally, as Guy Coder pointed out, when using +, -, etc its guaranteed that the type of the resulting expression is the same as the arguments so += always makes sense. On the other hand, we can have y.bar() return a type different from y, in which case .= bar() would make no sense.