Processing generics type info

[Damtev]

Description

We need to improve our processing of generics type info:

1. We may use info about parameter type of class to pass it to type info about its parametrized fields, for example:

class ParametrizedClass<T>  {
    T parametrizedField;
}

In this case, we may use the info that if an instance of ParametrizedClass is parametrized with type Integer (for example), thus field parametrizedField also has type Integer.

2. Also, we may make a connection between the parameters of a method and its return type, for example:

<T> T returnFirstElement(List<T> list);

In this case, we may use the info that a return value has the type of elements in the provided list.

[CaelmBleidd]

A helpful example of losing generic information for return values:

public List<Integer> genericAsReturnValue(List list) {
    return list;
}

public int useGenericInformation(List externalList) {
    List<Integer> list = genericAsReturnValue(externalList);
    UtMock.assume(list.get(0) != null);

    if (list.size() > 2) {
        return 1;
    } else {
        return 2;
    }
}

list must be a list of integer values, but it is constructed as a list of objects instead

[CaelmBleidd]

A bit more tricky example that should work after fixing this issue:

    public int functionWithSeveralTypeConstraintsForTheSameObject(GenericParent element) {
        if (element instanceof AnotherClassWithOneGeneric) {
            functionWithSeveralGenerics(
                    (AnotherClassWithOneGeneric<?>) element,
                    (ClassWithOneGeneric<?>) element
            );

            Object value = ((ClassWithOneGeneric<?>) element).value;
            UtMock.assume(value != null);

            if (value instanceof Number) {
                return 1;
            } else {
                return 2;
            }
        }

        return 3;
    }

    private <T, K extends Number> void functionWithSeveralGenerics(
            AnotherClassWithOneGeneric<K> firstValue,
            ClassWithOneGeneric<T> anotherValue
    ) {

    }
}

abstract class GenericParent {
}

class ClassWithOneGeneric<T> extends GenericParent {
    T value;
}

class AnotherClassWithOneGeneric<T extends Number> extends ClassWithOneGeneric<T> {
    T numberValue;
}

class ClassWithTwoGenerics<T, A> extends GenericParent {
}

The engine must not find a branch with 2 as a returned value