Front-end fails to reject method overloading on constrained types (place types)

Defer all open 2.0.1 issues to 2.0.2.

Defer all unresolved issues from 2.0.2 to 2.0.3.

defer all non-critical X10 issues to 2.1.0.

Bulk defer all non-critical, non-blocker frontend issues to 2.1.0.

bulk defer of unresolved 2.1.0 bugs to 2.1.1.

This is still a problem. Here is the new code that shows this:

abstract class Writer {
    public abstract def write(x: Byte): Void;

    public def write(buf: GlobalRef[Rail[Byte]]): Void {
        val mybuf = buf as GlobalRef[Rail[Byte]]{self.home==here};
        write(mybuf, 0, mybuf().length);
    }

    public def write(buf: GlobalRef[Rail[Byte]]{self.home==here}, off: Int, len: Int) {
        for (var i: Int = off; i < off+len; i++) {
            write(buf()(i));
        }
    }
}

class OutputStreamWriter extends Writer {
    public def write(x: Byte): Void { }

    public def write(buf: GlobalRef[Rail[Byte]]): Void {
    }

    // this overloads the method from Writer and should be illegal
    // need an additional check in the type system
    public def write(buf:GlobalRef[Rail[Byte]], off: Int, len: Int): Void {
    }
}

public class PlaceOverload {
  public static def main(args:Rail[String]) {}

  public def breakit(b:GlobalRef[Rail[byte]], w:OutputStreamWriter) {
    w.write(b, 0, 0);
  }
}

bulk move of all unresolved issues from 2.1.1 to 2.1.2

defer all non-critical 2.1.2 issues to 2.2.

I suspect this is a similar issue to XTENLANG-741 and XTENLANG-747, so fixing them would probably also fix this one.
This problem is currently caught by the compiler when attempting to invoke w.write(b, 0, 0):

./PlaceOverload.x10:29: Multiple methods match write(x10.lang.GlobalRef[x10.lang.Rail[x10.lang.Byte]]{self==b}, x10.lang.Int{self==0}, x10.lang.Int{self==0}) [method public OutputStreamWriter.write(buf: x10.lang.GlobalRef[x10.lang.Rail[x10.lang.Byte]], off: x10.lang.Int, len: x10.lang.Int), method public Writer.write(buf: x10.lang.GlobalRef[x10.lang.Rail[x10.lang.Byte]]{self.x10.lang.GlobalRef#home==here}, off: x10.lang.Int, len: x10.lang.Int)]
1 error.

Not ideal, but we will have to live with that for 2.2. We'll do something better for 2.2.1.

The situation with overloading, constrained arguments, method guards, generic types and implicit coercion can become quite tricky.

In general, the user should write code in such a way as to minimized confusing themselves, the readers of the code, or the compiler.

The general principle should be: If two methods have the same constraint erasure, then one must override the other. We should check this at method definition time (rather that at method use time, i.e. when type-checking calls).

We need to add additional rules in the type checker to check this condition. This will rule out the code for OutputStreamWriter above — its method write(buf:GlobalRef[Rail[Byte]], off: Int, len: Int) has the same erasure as Writer.write(buf: GlobalRef[Rail[Byte]]{self.home==here}, off: Int, len: Int) but does not override it.

Agreed.
this is a simpler test:

class A {
	def m(Int):void {}
}
class B extends A {
	def m(Int{self==1}):void {} // ShouldBeErr
}

Fixed in revision 21549.

bulk close of all 2.2.0 resolved issues.