###Original question asked for "ambiguous type". For that the answer was:

Ambiguous type, obviously none. The caller needs to know what they'll get, so it's isn't possible. All any language can return is either base type, interface (possibly auto-generated as in intersection type) or dynamic type (and dynamic type is basically just type with by-name call, get and set methods).

###Inferred interface:
So basically you want it to return an interface `IXY` that derives `IX` *and* `IY` though that interface was not declared in either `A` or `B`, possibly because wasn't declared when those types were defined. In that case:

 * Any that is dynamically typed, obviously.
 * I don't remember any statically typed mainstream language would be able to generate the interface (it is the **union** type of `A` and `B` or intersection type of `IX` and `IY`) itself.
 * [GO](http://golang.org/), because it's classes implement interface if they have the correct methods, without ever declaring them. So you just declare an interface that derives the two there and return it.
 * Obviously any other language where type can be defined to implement interface outside of definition of that type, but I don't think I remember any other than GO.
 * It's not possible in any type where implementing an interface has to be defined in the type definition itself. You can however work around in most of them by defining wrapper that implements the two interfaces and delegates all methods to a wrapped object.

**P.S.** A *strongly* typed language is one in which an object of given type can't be treated as object of another type, while *weakly* typed language is one that has a reinterpret cast. Thus *all dynamically typed languages are strongly typed*, while weakly typed languages are assembly, C and C++, all three being typed *statically*.