Resolution errors for forwarded virtual methods on generic classes

[benharsh]

Summary of Problem

A forwarded virtual method on a generic class can confuse the compiler, which may attempt to select the wrong method to forward/resolve.

Associated Future Test(s):
test/classes/forwarding/forwardGenericVirtual.chpl

class Base {
  // Removing this somehow avoids the bug...
  proc action(a) {
    halt("Should not see this!");
  }
}

class View : Base {
  var arr;

  forwarding arr;
}

class Rect : Base {
  param rank : int;

  proc inner(x) where x.rank == this.rank {
    writeln("Inner called on ", this.type:string, " with ", x.type:string);
  }

  proc action(a) {
    if a.rank != this.rank {
      compilerWarning("Rank mismatch between ", a.type:string, " and ", this.type:string);
    }
    inner(a);
  }
}

var one = new Rect(1);
var three = new Rect(3);
var v = new View(three);

one.action(one);
v.action(three);

[mppf]

This issue is coming from the combination of forwarding + inheritance.

In this case, proc action is a method on Base. We are trying to forward a call proc action from class View : Base but proc action already resolves for class View by using the implementation in Base. The result is that forwarding does not apply; rather v.action is running Base.action.

This might be surprising but in this event forwarding is functioning as designed.

[bradcray]

@benharsh, @mppf: Just wondering what we should do w.r.t. this issue. Ben, can you say more about what led to its being filed?

[benharsh]

According to #7585, it looks like I ran into this while working on some array view bulk-transfer stuff.

[mppf]

I think we should close the issue, because everything is working the way I'd expect. @benharsh - if you want to argue for changing the disambiguation rules you are welcome to do so.

[mppf]

I had a short discussion with @benharsh and answered a question - based upon the above comment, it seemed that it should compile but halt at runtime.

The reason it doesn't is this:

• the action(a) procedure is generic
• so if Base.action(a:SomeType) is instantiated, so too will be Rect.action(a:SomeType), because a virtual dispatch on Base might call the version on Rect
• As a result, Rect.action is instantiated with a Rect(3) argument, which leads to the compilation error