Stack too deep | Use memory array to store many "local" variables?

Question

I have a contract that's doing a fairly complex calculation with some intermediate calculations, and I'm running into the "stack too deep" problem.

I've tried to use a memory array within the function to save temporary "local variables" instead of creating new local variables.

For example, instead of:

function usingLocalVars() {
  // Get 3 uint values from a getter function call from another contract
  // and save as local variables uint a, uint b, uint c:
  var(a, b, c) = otherContract.getter(param);

  // Perform some computation an a, b, and c and save as another variable d
  uint d = someOperation(a, b, c);

  /** other code with a return **/

}

Re-written using memory array:

function usingMemoryArray() {
  // Get 3 uint values from a getter function call from another contract
  // and store into memory array temp:

  // create memory array
  uint[4] memory temp;

  // save values into memory array
  (temp[0], temp[1], temp[2]) = otherContract.getter(param);

  // Perform some computation an a, b, and c and save into temp[3]
  temp[3] = someOperation(temp[0], temp[1], temp[2]);

  /** other code with a return **/
}

So what I've tried to do:

1. Eliminate almost all local variables by doing the above (memory array)
2. Removed all named return variables, i.e. returns (uint x, uint y, uint z) => returns (uint, uint, uint)

Current function summary:

• 1x function input paramater
• memory array of length 17 (all my "temp" variables)
• 1x int local variable
• The function does call some other methods within the contract (such as someOperation()) above. Would this potentially be another cause of this problem? Needing to limit the local var used in other method calls (e.g. someOperation())?

Does using a memory array as I mentioned above actually help for this problem (stack too deep)?

Answer 1

So my temp variable assignments were causing the problem. It works if limiting to 8 assignments at a time:

This fails (9 variable assignments):

(temp[0], temp[1], temp[2], temp[3], temp[4], temp[5], temp[6], temp[7], temp[8]) = (1, 2, 3, 4, 5, 6, 7, 8, 9);

But this works (8 assignments at a time):

(temp[0], temp[1], temp[2], temp[3], temp[4], temp[5], temp[6], temp[7]) = (1, 2, 3, 4, 5, 6, 7, 8);
(temp[8], temp[9], temp[10], temp[11], temp[12], temp[13], temp[14], temp[15]) = (9, 10, 11, 12, 13, 14, 15, 16);

And also, using the memory array does avoid the stack too deep problem of local variables.

Answer 2

Maybe you've tried this but some debugging in Remix with empty getter() and someOperation() functions that just return values shows the max stack depth reaches 12 items when I use the first method but only 9 for the second. I'm yet to fully understand the differences but consider using remix and checking the debug screen to help if you haven't already.