Support auto-splatting in captured block literals

[HertzDevil]

Resolves #7706.

In a case like

def foo(&block : {Int32, Char} -> _)
  tup = {1, 'a'}
  block.call tup
end

foo do |x, y|
  {x, y}
end

The compiler now rewrites the block into the following ProcLiteral:

->(__temp : {Int32, Char}) do
  x = __temp[0]
  y = __temp[1]
  {x, y}
end

The conditions for auto-splatting are the same as non-captured blocks: the block must accept a single Tuple instance, there must be 2 or more block parameters, and none of these parameters must be a splat.

When there are fewer block parameters than tuple elements, the whole tuple is still passed but the __temp assignments corresponding to the missing parameters will be gone.

Tuple unpacking of individual block parameters is also possible. For example, given

def foo(&block : Tuple(Tuple(Int32, Char), Bool, Float64) -> _)
  tup = { {1, 'a'}, true, 1.0 }
  block.call tup
end

foo do |(x, y), z|
  {x, y, z} # => {1, 'a', true}
end

The expanded Proc is more or less equivalent to

->(__temp_1 : Tuple(Tuple(Int32, Char), Bool, Float64)) do
  __arg0 = __temp_1[0]
  z = __temp_1[1]
  # __temp_1[2] not accessed

  x = __arg0[0]
  y = __arg0[1]

  {x, y, z}
end

Internally (x, y) is transformed into __arg0 by the parser; __temp_1 is injected in the semantic phase when the block is actually matched against the enclosing method.

[asterite]

Awesome!

[bcardiff]

FYI, This CI is complaining for real in this PR in spec/compiler/semantic/closure_spec.cr:385, although for some reason it didn't fail on all platforms 🤔

[HertzDevil]

Ah this is because I forgot to change some expected assert_error messages. Push will be up soon...

[bcardiff]

It's still failing just on some platforms. The merge from master was done in an old commit. I am not sure if that's the reason.