Name: nt126004 Date: 02/06/2003


FULL PRODUCT VERSION :
java version "1.4.1_01"
Java(TM) 2 Runtime Environment, Standard Edition (build 1.4.1_01-b01)
Java HotSpot(TM) Client VM (build 1.4.1_01-b01, mixed mode)


FULL OPERATING SYSTEM VERSION :
SunOS kona 5.7 Generic_106541-12 sun4u sparc SUNW,Ultra-2

EXTRA RELEVANT SYSTEM CONFIGURATION :
None


A DESCRIPTION OF THE PROBLEM :
Consider the following Supertype class.

public class Supertype {
  public void m1(Object o) {
  }

  public void m1(Foo f) {
  }
}

in it I define two overloaded methods, m1, one of which
takes an Object, the other which takes a Foo. The
definition of Foo is the empty class, i.e.,

public class Foo {
}

Now, consider this class which extends the above Supertype.

public class Subtype extends Supertype {
  public void m1(Object o) {
    super.m1(o);
  }
}

This class deliberately overloads the Supertype.m1(Object o)
method but does not provide a m1(Foo f) method as the author
of Subtype wants to use m1(Foo f) defined on Supertype.
Let's assume that all the above classes are provided by a
company, i.e., I do not have control over the source code.

I want to then write this code:

public class Test {
  public void amethod() {
    Subtype st = new Subtype();
    Foo f = new Foo();
    st.m1(f);
  }
}

I create an instance of Subtype (called st), create a Foo
object (f) and pass this to the st.m1(f) method. I then
compile the above code with jdk 1.4.1 and get this error
message.

Test.java:5: reference to m1 is ambiguous, both method
m1(Foo) in Supertype and method m1(java.lang.Object) in
Subtype match
    st.m1(f);

The above error message is correct. As currently defined
the Java language cannot determine which m1 method to call.

However, *at the type level* there is an m1(Foo f)
available to instances of Subtype, it is just that
its semantics are defined at Supertype. Therefore,
why is the above call an error? Why can the compiler
NOT work out which m1 method I want to call?

If I make the st.m1 method invocation this:

    st.m1((Object) f);

the code WILL compile and I call up the hierarchy using
the m1(Object o) definitions of the method.

However, and this is what is confusing me, is that
this call:

    st.m1((Foo) f);

still results in the compiler generating the error.
Why is this, I can tell the language that f should
be treated as an Object, but I can't have it treated
as a Foo.

If I explicitly provide a:

  public void m1(Foo f) {
  }

on Subtype.java, the problem goes away as the ambiguity
has been removed. So, why do I have to provide the
m1(Foo f) to remove the ambiguity? Subtype.java has
an m1(Foo), in the same way the Supertype has an equals
available to it, which is defined on java.lang.Object.

The above is a problem which is made worse by considering
a subtype of the Subtype class. Consider this class
that subtypes the Subtype class.

public class SubSubtype extends Subtype {
  public void t() {
    super.m1(new Foo());
  }
}

In the unrelated t() method I would like to perform
a super call to call the m1(Foo f) method the is
available to me through subtyping. However, the Java
language *COMPLETELY PREVENTS ME FROM CALLING IT*.

The only way to call up to an m1 on Subtype is to do
this:

    super.m1((Object) new Foo());

which means the m1(Object o) method on Subtype is called,
which, in turn, calls m1(Object o) on Supertype which is
NOT what I want to call.

In t(), I cannot do either of these:

  super.super.m1(new Foo());
  ((Supertype) super).m1(new Foo());

which would allow me to skip up the hierarchy to the
Supertype level to call the method I want to call,
in a way that is similar to C++. This would solve
the problem, but it isn't nice.

The reason this is a practical problem is because
Supertype and Subtype may have been made available to
me as a library, i.e., I do not have access to the
source code.

I may then create my SubSubtype and not be able to
call up the hierarchy to the m1(Foo f) method due to
the Java language semantics.

Being prevented from making this call is why I say that
subtyping has been broken in the Java language.

I have tested this with these versions of Java (on the
architecture I indicate above) and the result is always
the same.

jdk1.0.2 jdk1.1.4 jdk1.1.5 jdk1.1.6 jdk1.1.7 jdk1.1.8 jdk1.2
jdk1.2.2 jdk1.2.2_007 jdk1.3.0 jdk1.3.1 jdk1.4.0 jdk1.4.1

Is this a feature of the language due to the way subtyping
behaves in conjunction with overloaded methods, i.e., this
is a way of ensuring ambiguity doesn't arise by disallowing
certain usages? For example, these three m1 methods defined
on Supertype.

public class Supertype {
  public void m1(Object o) {
  }

  public void m1(Foo f) {
  }

  public void m1(Bar b) {
  }
}

and Bar is a subtype of Foo. Is this difficult to type or
efficiently implement in a Java-like object-oriented
language?


STEPS TO FOLLOW TO REPRODUCE THE PROBLEM :
1. Please see above
2.
3.

ERROR MESSAGES/STACK TRACES THAT OCCUR :
As above, the compiler fails to compile the code.


REPRODUCIBILITY :
This bug can be reproduced always.

---------- BEGIN SOURCE ----------
As above.

---------- END SOURCE ----------

CUSTOMER WORKAROUND :
There isn't one.
(Review ID: 180893)
======================================================================