Bullet-proofing companion objects

[odersky]

Companion class/module computations now also work for local classes and modules. For this to work,
either one of two conditions must be met: (1) some enclosing context refers to a scope that
contains the companions. (2) the context's compilation unit has a typed tree that contains the
companions. (1) is usually true when type-checking, (2) when transforming trees.

Local companions are searched as follows: If (2) holds, we locate the statement sequence containing
the companions by searching down from the root stored in the compilation unit. Otherwise, we search
outwards in the enclosing contexts for a scope containing the
companions.

[odersky]

Review by @DarkDimius @retronym

[retronym]

This looks a bit dicey to me. Could this search be expressed with a regular TreeAccumulator, customized to prune based on positions?

[odersky]

That's an interesting idea. But it would affect more code than just this one. I.e. compare with Positioned#contains, which is used in Inferencing to determine whether a type variable may be instantiated. So I prefer delegating a change like this to a separate commit.

[retronym]

The duplication with Positioned#contains makes it all the more worthwhile to either factor out this productIterator based approach or replace it with a TreeAccumulator :)

[retronym]

Here's a stab at the refactoring: #76

[retronym]

we locate the statement sequence containing the companions by searching down from the root stored in the compilation unit.

What about a Transformer that, say, duplicates method bodies (like specialization). The new symbols for the class/module would not be locatable in unit.root.

scalac blows up before it gets to that point:

class C[@specialized(Int) X] {
  def foo(x: X) = {
    class C {
       private def y: Any = C.x
    }
    object C {
      private def x: Any = new C().y
    }
    (y: Int) => x
  }
}

% scalac-hash v2.11.0-RC1 -no-specialization sandbox/test.scala
% scalac-hash v2.11.0-RC1 sandbox/test.scala
sandbox/test.scala:6: error: C is already defined as class C
    object C {
           ^
one error found

[DarkDimius]

LGTM

[DarkDimius]

What about a Transformer that, say, duplicates method bodies (like specialization). The new symbols for the class/module would not be locatable in unit.root.

@retronym why would they, AFAIK specialization creates new symbols with custom suffix, and they enter scope of their owner, amirite?

[retronym]

Compiling with -optimise eliminates the closure, we rely on that in scalac.

[retronym]

It seems that this code is never executed by current tests. I guess that's expected as we don't have transformer phases calling companionModule right now, but it would be good to mention that sort of thing explicitly in the pull request.

[retronym]

@DarkDimius The part of specialization I was referring to is Duplicators.{retyped, BodyDuplicator}. That's actuallly expressed as a Typer, rather than a simple transformer, so it wouldn't go through the defPath route in dotty.

I can't actually think of any places in scalac that would need to call companionModule on local classes in a transformer phase. extmethods only works on top-level classes. Maybe if you deferred the full translation of names/defaults a bit, you would hit it, as constructor defaults end up in the companion object.

[DarkDimius]

FYI: I'm implementing lazyvals transformer in dotty and it uses companionModule to store field offsets to be able to invoke Unsafe.compareAndSwapLong.
So, at least this implementation, will indeed call companionModule on local classes.

[retronym]

Okay. So long as the symbols for the class/module exist in the tree that was fed into the phase, this approach ought to work. But if you ended up with new symbols for some reason, I think it could be brittle.

[retronym]

Oh, I guess you might have to will the companion module into existence during that phase, if one doesn't already exist. So you might get into interesting territory.

[retronym]

Come to think of it, you might be better adding the offsets as static members of the class, rather than to the companion. See the reflection cache added for structural types as an example.