VM not instantiating closure tear off type parameters to bounds

[biggs0125]

class A<P> {
  final List bar2TypeArguments = [];

  void foo<Q1>() {
    void bar<T1>(List<T1>? arg) {
      void bar2<T2 extends Map<Q1, T1>>(List<T2>? arg) {
        bar2TypeArguments..add(T2);
      }

      dynamic f = bar2;
      f(null);
    }

    // Call with explicit type arguments.
    bar<int>(null);
  }
}

void main() {
  final a = new A<int>();
  a.foo<num>();
  print(a.bar2TypeArguments);  // Expect "[Map<num, int>]" but get "[Map<dynamic, dynamic>]"
}

In this test A.foo.Q1 is instantiated to num and A.foo.bar.T1 is instantiated to int. So when bar2 gets torn-off and invoked dynamically, A.foo.bar.bar2.T2 should be instantiated to its bounds which is Map<A.foo.Q1, A.foo.bar.T1> or in this context Map<num, int>.

Failing test
Test introduced in this CL

[alexmarkov]

It looks like we're not instantiating default type arguments during dynamic closure calls. /cc @sstrickl

[a-siva]

@sstrickl I assume you are going to pick this up.

[mkustermann]

@sstrickl I assume you are going to pick this up.

@a-siva in that case we should assign @sstrickl :)

[sstrickl]

So looking at the code, when we instantiate default type arguments inside a closure function, we use the same code as other types of functions. That means we use the instantiator and function type arguments passed to the function to instantiate the default type arguments, instead of using the instantiator type arguments and parent function type arguments stored in the closure if this is a closure function.

(We do properly use them to instantiate the default type arguments during the type checking that happens within the invoke field dispatcher that handles the dynamic closure call, but that's only used for type checking within the dispatcher and the original function type arguments, if any, are passed through unchanged.)

So the fix is relatively straightforward. However, I'm taking a deeper look at it because the simplest fix would cause us to recompute this every time the closure is called. Instead, we should probably instead precompute and cache the instantiation of the default type arguments at closure creation time, trading off a bit of space in the closure object to avoid repeated TAV instantiation within the closure function and also removing the instantiation done within the invoke field dispatcher with a simple field load instead.