Autoref for temporaries in argument position

I often see code like (a + b).cmp(&(c + d)). Both the self argument and the first method argument of cmp are reference types, but only the self argument automatically gets a reference taken.

I suggest that function and method arguments should also automatically get their address taken, if and only if they are temporaries. Rvalue references are copied if they are Copy and thus are then temporaries and get their address taken automatically

So the above example could now be (a + b).cmp(c + d).

Things allowed under this scheme

• (a + b).cmp(c + d)
• foo.cmp(&bar)
• foo.cmp(&vec[42])

Things not allowed under this scheme

• foo.cmp(bar) if bar is not a reference type or a Copy type
• foo.cmp(vec[42]) if vec's elements are not references or a Copy type
  • e.g. if the vec elements are i32 this would be allowed, but not if they are String

Locations where to apply autoref

• function arguments
• index op argument
• struct constructor field initialization expressions
• tuple field initialization expressions
• array element initialization expressions

Start by reviewing the issue's allowed and disallowed examples and the listed locations where autoref would apply. Determine the language-semantics and implementation entry points for argument, index, struct, tuple, and array initialization handling; done means the proposal has an agreed design and coverage for each stated case.