reflect

`Class.newInstance()` was deprecated in Java 9.

This commit adds the infrastructure for caching of component metadata rules.

For now, the only kind of rule we can cache are the component metadata supplier

rules, which are used during dynamic version selection, but the executor

infrastructure can be reused to cache more kinds of rules.

The implementation relies on the principal that a "rule" can be safely cached if:

- the rule has no side effect, and uses the "class-based pattern"

- the implementation of the rule didn't change

- the inputs of the rule didn't change

For this, we introduce a new persistent cache (hence cross-build) with an in-memory

facing cache, that allows us to avoid the execution of a rule if the result is

already in the cache. The implementation makes use of _snapshotting_ to capture the

state of the inputs of a rule, which consists of the implementation of the rule and

its potential parameters. It's worth noting that at this stage we do not consider

the services the rule can use, it's going to be done in a subsequent commit.

This worked required a clarification of what an rule cares about (the result) in

opposition to what the user is faced with. For example, a component metadata supplier

rule output is a `ComponentMetadata`, but what we offer to the user, to build that

metadata, is a `ComponentMetadataSupplierDetails` instance. Similarly, component

metadata rules would have different kind of output and what the user manipulates.

The cache works with a primary key (for the first implemented cache, the key is the

module version identifier) and will invalidate the results based on the cache policy

(should refresh modules).

The persistent cache uses the snapshot as the key in the store. In theory, should we

consider that we have a nearly perfect hash function, we could instead use the hash

of the snapshot as the key. Measurements would have to be made to check if it's worth

implementing.

The reflection cache keeps a set of property names for each class.

This set was provided by calling keySet() on a map which contains

class values. The keyset would thus keep a strong reference back

to its map and all of its values, leading to a classloader leak.

We now do a defensive copy of they keyset to avoid surprises for

callers of this method.

With javax.annotation.Nullable.

This avoids leaking an internal exception type through the

ObjectFactory.newInstance API.

And introduce `TypeOf.Visitor`.

And fix basic wildcard type case, e.g. List<?>

and by being so, faithfully represent generic types.

Calling `getGenericParameterTypes` is very expensive, and usage of `EqualsBuilder` implies calling the methods

even if they shouldn't be. This reworks the algorithm to avoid use of equals builder, and also changes the

generated hash code to use parameter types instead of generic parameter types.

This shaves a few ms for cold daemon startup (first use case, or `--no-daemon`).

There was an error in `buildSrc` compilation for some performance tests due to missing log4j dependency.

Signed-off-by: Cedric Champeau <cedric@gradle.com>

The reflection cache is now safer, because we use a hierarchical cache where

the node entries are weakly referenced `Class` instances. Typically the first

level of the cache would be the receiver, while lower levels would be the

argument types. If those types are collected, the weak hash maps that we use

internally would automatically clean the entries. Eventually, the value associated

with this "path" of `Class` itself references a `Method` or a `Constructor`

with additional, computed, data.

The advantage of this approach is that typically for the instantiator case,

we no longer need to match the argument types (`isMatch`) for each call: instead,

we go through the tree using subsequent argument types, and if a match is found,

we know it's the right one.