Interestingly, at a quick glance, the optimizer seems to be handling this rather well even for larger-than-16-elements-arrays (without having to use stack-to-memory).

Random idea for a syntax test on this:

function f(uint256[] memory x) {}
function f(uint256[3] memory x) {}
function g() {
  f([1]); // should work
  f([1,2,3]); // should fail (no unique function)
  f([1,2,3,4]); // should work
}

This should work already, but good to have a test for it.

Please note that I think it makes sense to re-unify this with tuple type again. For now, it helps to find places where it is used as an inline array, but in the end, they types are very similar, especially when we keep just putting things on the stack.

This pull request is stale because it has been open for 14 days with no activity.
It will be closed in 7 days unless the stale label is removed.

This pull request was closed due to a lack of activity for 7 days after it was stale.

Thank you for your contribution to the Solidity compiler! A team member will follow up shortly.

If you haven't read our contributing guidelines and our review checklist before, please do it now, this makes the reviewing process and accepting your contribution smoother.

If you have any questions or need our help, feel free to post them in the PR or talk to us directly on the #solidity-dev channel on Matrix.

Closing for now.