Tests whether a given parameter can be given to a static method like ImmutableMap.copyOf to produce a value that can be assigned to the given target type.

For example, suppose we have this method in ImmutableMap:
static <K, V> ImmutableMap<K, V> copyOf(Map<? extends K, ? extends V>)
and we want to know if we can do this:

ImmutableMap<String, Integer> actualParameter = ...;
ImmutableMap<String, Number> target = ImmutableMap.copyOf(actualParameter);

The logic makes some simplifying assumptions, which are met for the copyOf and of methods that we use this for. The method must be static, it must have exactly one parameter, and it must have type parameters without bounds that are the same as the type parameters of its return type. We can see that these assumptions are met for the ImmutableMap.copyOf example above.

Returns a map from methods to return types, where the return types are not necessarily the original return types of the methods. Consider this example:

@AutoValue class Foo<T> {
  abstract T getFoo();

  @AutoValue.Builder
  abstract class Builder<T> {
    abstract Builder setFoo(T t);
    abstract Foo<T> build();
  }
}

We do the rewrite this way around (applying the type parameter from Foo.Builder to Foo) because if we hit one of the historical Eclipse bugs with Types#asMemberOf then EclipseHack#methodReturnType can use fallback logic, which only works for methods with no arguments.

Parameters

methods:Collection<javax.lang.model.element.ExecutableElement>

the methods whose return types are to be rewritten.

sourceType:javax.lang.model.element.TypeElement

the class containing those methods (Foo in the example).

targetType:javax.lang.model.element.TypeElement

the class to translate the methods into (Foo.Builder<T>) in the example.