Join doesn't treat correctly variance of generics

[ilevkivskyi]

Currently, joins for the instances of same type are calculated using this code:

        if is_subtype(t, s) or is_subtype(s, t):
            args = []
            for i in range(len(t.args)):
                args.append(join_types(t.args[i], s.args[i]))
            return Instance(t.type, args)

This has two problems:

• For a covariant generic G, the join of G[int] and G[str], is currently just object, not G[object] as it (I believe) should be.
• This behaviour is wrong for contravariant types, in this case there should be a meet of arguments: so that join(C[int], C[float]) should be C[int] for contravariant C, while currently it is C[float].

A correct behaviour would to check for every type argument position:

• if the class is covariant in it, calculate join of args on the left and right
• if the class is contravariant in it, calculate meet of args
• if the class is invariant in it, check that the type on the left and right are the same
• if the last one didn't hold, fall back to object.
• verify bounds and values restrictions for new args, if some are not satisfied, fall back to object.
• (optional) if one of the meets in third bullet produced an UninhabitedType, fall back to object as well.

[ilevkivskyi]

An additional important step is to verify bounds and values before creating a new instance. I edited the description.

[ilevkivskyi]

#4170 provides a real-world example of this problem.