feat: properly parse and resolve tuples

[JairusSW]

This PR adds basic support for the Tuples. Roadmap wise, this, along with a few more PRs, will pave the way for the Multi Value Proposal to be properly implemented.

The goal of this PR is not to add full-fledged support for Tuples. Instead, it supports the basic functionality for parsing and resolving them since optimal Tuple implementation relies on Multi Value support.

The order of the PRs to implement are:

1. Parse and resolve tuples
2. Hook up Multi Value support to binaryen
3. Clean up, test, and enable multi-value by default

Speaking of that, all the features here hide behind --enable multi-value

So far, this implements:

• Parser

  • Parameters: function foo(x: [i32, i32]) {}
  • Return types: function foo(): [i32, i32] {}
  • Return values syntax: return [0, 1]
  • Type aliases: type Foo = [i32, i32]
  • Type names: [x: f64, y: f64]

• Compiler

  • Tuple usages error with not implemented (for now)

• I've read the contributing guidelines

• I've added my name and email to the NOTICE file

[MaxGraey]

LGTM

But let someone else take a fresh look at this

[HerrCai0907]

LGTM.
But I think tuple does not rely on multi-value. Here is my implement of tuple in AS. maybe you can ref it if you are interesting to implement the whole tuple support. wasm-ecosystem/warpo#269

[HerrCai0907]

Actually tuple doesn't and is impossible to rely on mutli-value.

declare function f(): [i32,i32];
function b() {
  let a = f();
  let b = a;
  b[0] = 1;
  assert(a[0] == 1);
}

In this cases, multiple value cannot handle this case since it treat the whole tuple as a value instead of a heap object.

[JairusSW]

@HerrCai0907, I'll add full support for tuples in the future. Tuples will need to exist in two forms:

1. Tuple becomes multi value when returned from function
2. When used as a heap type (eg. store<[i32, i32]>(), Array<[i32, i32]>), it becomes a heap type

Then, depending on usage, tuples will be lifted and lowered from multi-value to tuple