Inner def with default param in a Scala.js-defined JS class produces invalid IR

[sjrd]

Reproduction:

import scala.scalajs.js
import js.annotation._

@ScalaJSDefined
class Foo extends js.Object {
  def bar(): Int = {
    def inner(start: Int = 0): Int = start + 1
    inner()
  }
}

object HelloWorld extends js.JSApp {
  def main() {
    val foo = new Foo
    assert(foo.bar() == 1)
  }
}

IR checker error:

[error] file:/localhome/doeraene/projects/scalajs/examples/helloworld/HelloWorld.scala(15:5:UndefinedParam): Invalid expression tree

[gzm0]

Note: The same applies to private methods with default parameters. The problem essentially boils down to this: The calling convention for private and lifte methods of Scala.js defined JS classes is not the same as for public and protected methods (scala conventions versus JS conventions). However, the compiler's default param handling does not honor that.

[gzm0]

I'm kind of stuck on this. The problem is that isRawJSDefaultParam does not take into account whether the target on the owner is an exposed method or not.

However, I'm unable to find out how I can reliably get the target of a default method. Currently I do:

isExposed(sym.owner.tpe.decl(nme.defaultGetterToMethod(sym.name)))

This fails for some local method definitions. I haven't been able to figure out when exactly, but telling me that Scalac's owner chain handling at this phase is broken wouldn't astonish me at all.

I need to think :) If anybody has an idea, please let me know.

[sjrd]

1. Try sym.owner.info instead of tpe
2. Careful with overloads. The result of decl() could be an OverloadedSymbol. You probably need to select the one alternative that has default parameters (there cannot be 2 or more, as per the Scala spec).

[gzm0]

sym.owner.info doesn't help. I'm aware of the overloading issue.

I can't even make a sandbox example that triggers the issue... In HelloWorld, everything works fine. I'm kind of glad the test triggered this corner case.

[sjrd]

Maybe the problem happens with separate compilation, i.e., if the default accessor you're calling has been compiled by a different compiler run (in a library). That would explain the difficulty to reproduce in the helloworld. Try calling a method of the stdlib from the helloworld.

[gzm0]

That might also be problematic. But the code I'm looking at is literally the same code, it's just in a different context:

class Outer {
  def default_values_in_non_exposed_methods(): Unit = {
    @ScalaJSDefined
    class DefaultParameters(val default: Int) extends js.Object {
      /* We don't use a constant default value to make sure it actually comes
       * from the default parameter accessors.
       */
      private def privateWithDefault(x: Int = default) = x


      def callPrivate(): Int = privateWithDefault()
      def callNested(): Int = {
        def nested(x: Int = default) = x
        nested() // this fails in the test
      }
    }

    val x = new DefaultParameters(5)
    //assertEquals(5, x.callPrivate())
    //assertEquals(5, x.callNested())
  }
}