Keep types in signatures of function types properly instantiated as the function

Keep types in signatures of function types properly instantiated as the function
type itself gets instantiated.
Until now, the signature was kept unchanged and the instantiation was reflected
by the type arguments of the function type only. This delayed instantiation
would complicate the implementation of generic functions.
This cl actually removes type arguments for (non-typedef) function types. The
function type is now fully represented by the signature. When the function type
is instantiated, a new signature is allocated (instead of a new type argument
vector) to hold instantiated result type and formal parameter types.
The same applies in the case of typedef function types, however, the type
arguments of the typedef are kept as before. This allows for better printing
of typedef function types and for finalization of recursive type involving
typedefs as type arguments.

R=asiva@google.com

Committed: https://github.com/dart-lang/sdk/commit/5f5a698100be7b145168490dfb81cd436ce1b8ff

[regis, 2017-04-04 17:19:45]

regis@google.com changed reviewers:
+ asiva@google.com, rmacnak@google.com

[regis, 2017-04-04 17:19:46]

This is one more cleanup/improvement that will simplify reification of generic
functions.

[siva, 2017-04-06 19:08:33]

lgtm

https://codereview.chromium.org/2793033005/diff/1/runtime/vm/class_finalizer.cc
File runtime/vm/class_finalizer.cc (right):

https://codereview.chromium.org/2793033005/diff/1/runtime/vm/class_finalizer....
runtime/vm/class_finalizer.cc:1270: }
ASSERT(signature.HasInstantiatedSignature()) here? or is it that if the
scope_class IsGeneric() is not true then the signature doesn't have to be
instantiated.

[regis, 2017-04-06 19:28:38]

Thanks!

https://codereview.chromium.org/2793033005/diff/1/runtime/vm/class_finalizer.cc
File runtime/vm/class_finalizer.cc (right):

https://codereview.chromium.org/2793033005/diff/1/runtime/vm/class_finalizer....
runtime/vm/class_finalizer.cc:1270: }
On 2017/04/06 19:08:33, siva wrote:
> ASSERT(signature.HasInstantiatedSignature()) here? or is it that if the
> scope_class IsGeneric() is not true then the signature doesn't have to be
> instantiated.

Not quite. The instantiation is merely a substitution. The signature may still
be uninstantiated, but not relatively to the typedef type parameters. Example:
typedef void F<T>(T x);
The signature is uninstantiated: '(T x) => void'.
Now, if you declare a F<K> inside a class C<K> {} and finalize the function type
F<K>, its signature gets instantiated from '(T x) => void' to '(K x) => void',
but it is still uninstantiated, because K is a type parameter.
I added a comment.

[regis, 2017-04-06 19:28:58]

Description was changed from

==========
Keep types in signatures of function types properly instantiated as the function
type itself gets instantiated.
Until now, the signature was kept unchanged and the instantiation was reflected
by the type arguments of the function type only. This delayed instantiation
would complicate the implementation of generic functions.
This cl actually removes type arguments for (non-typedef) function types. The
function type is now fully represented by the signature. When the function type
is instantiated, a new signature is allocated (instead of a new type argument
vector) to hold instantiated result type and formal parameter types.
The same applies in the case of typedef function types, however, the type
arguments of the typedef are kept as before. This allows for better printing
of typedef function types and for finalization of recursive type involving
typedefs as type arguments.
==========

to

==========
Keep types in signatures of function types properly instantiated as the function
type itself gets instantiated.
Until now, the signature was kept unchanged and the instantiation was reflected
by the type arguments of the function type only. This delayed instantiation
would complicate the implementation of generic functions.
This cl actually removes type arguments for (non-typedef) function types. The
function type is now fully represented by the signature. When the function type
is instantiated, a new signature is allocated (instead of a new type argument
vector) to hold instantiated result type and formal parameter types.
The same applies in the case of typedef function types, however, the type
arguments of the typedef are kept as before. This allows for better printing
of typedef function types and for finalization of recursive type involving
typedefs as type arguments.

R=asiva@google.com

Committed:
https://github.com/dart-lang/sdk/commit/5f5a698100be7b145168490dfb81cd436ce1b8ff
==========

[regis, 2017-04-06 19:28:59]

Committed patchset #2 (id:20001) manually as
5f5a698100be7b145168490dfb81cd436ce1b8ff (presubmit successful).