trait lazy val with path-dependent type should not crash during fields

[adriaanm]

class Global { class Name }

trait CommonPrintUtils {
  val global: Global 
  import global._

  lazy val precedence: Name => Int = ???
}

trait CompilerProvider {
  val global: Global = ???
}

class AbstractPrinter extends CommonPrintUtils with CompilerProvider 

Crashes with (under -uniqid -Ydebug ):

error: scala.reflect.internal.Types$TypeError: type mismatch;
 found   : scala#25.this.Function1#1283[AbstractPrinter#6560.this.global#14333.Name#6687,scala#25.this.Int#929]
 required: scala#25.this.Function1#1283[AbstractPrinter#6560.this.global#14238.Name#6687,scala#25.this.Int#929]

[...]
    at scala.tools.nsc.transform.Fields$FieldsTransformer.typedPos(Fields.scala:511)
    at scala.tools.nsc.transform.AccessorSynthesis$CheckedAccessorTreeSynthesis$SynthLazyAccessorsIn.$anonfun$expandLazyClassMember$5(AccessorSynthesis.scala:356)
    at scala.tools.nsc.transform.AccessorSynthesis$CheckedAccessorTreeSynthesis$SynthLazyAccessorsIn.$anonfun$expandLazyClassMember$4(AccessorSynthesis.scala:356)
    at scala.tools.nsc.transform.AccessorSynthesis$CheckedAccessorTreeSynthesis$SynthLazyAccessorsIn.expandLazyClassMember(AccessorSynthesis.scala:356)
    at scala.tools.nsc.transform.Fields$FieldsTransformer.superLazy$1(Fields.scala:636)
    at scala.tools.nsc.transform.Fields$FieldsTransformer.$anonfun$fieldsAndAccessors$3(Fields.scala:641)
    at scala.tools.nsc.transform.Fields$FieldsTransformer.fieldsAndAccessors(Fields.scala:639)

[adriaanm]

Somehow the global in CommonPrintUtils and CompilerProvider give rise to different singleton types when type checking AbstractPrinter.this.precedence = AbstractPrinter.super.precedence(); in AbstractPrinter

The expected tree at fields would look something like:

  trait CommonPrintUtils extends Object {
    <stable> <accessor> def global(): Global;
    <stable> <accessor> lazy <sub_synth> def precedence(): global.Name => Int = scala.Predef.???()
  }

  abstract trait CompilerProvider extends Object with CommonPrintUtils {
    <accessor> <sub_synth> protected[this] def CompilerProvider$_setter_$global_=(x$1: Global): Unit;
    <stable> <accessor> <sub_synth> def global(): Global = scala.Predef.???()
  }

  class AbstractPrinter extends Object with CompilerProvider {
    override <stable> <accessor> def global(): Global = AbstractPrinter.this.global;
    private[this] val global: Global = _;
    override <accessor> protected[this] def CompilerProvider$_setter_$global_=(x$1: Global): Unit = AbstractPrinter.this.global = x$1;
    final <synthetic> lazy private[this] var precedence: global.Name => Int = _;
    private def precedence$lzycompute(): global.Name => Int = {
      AbstractPrinter.this.synchronized[Unit](if (AbstractPrinter.this.bitmap$0.unary_!())
        {
          AbstractPrinter.this.precedence = AbstractPrinter.super.precedence();
          AbstractPrinter.this.bitmap$0 = true
        });
      AbstractPrinter.this.precedence
    };

    override <stable> <accessor> lazy def precedence(): global.Name => Int = 
      if (AbstractPrinter.this.bitmap$0.unary_!())  AbstractPrinter.this.precedence$lzycompute()
      else AbstractPrinter.this.precedence;

    @volatile private[this] var bitmap$0: Boolean = _;
  }

[adriaanm]

Current hypo: the type of the lazy var is determined when the global accessor has not yet been created in AbstractPrinter, and thus the CompilerProvider's accessor is used. When we're mixing in the impl of precedence$lzycompute in AbstractPrinter, the RHS of the assignment will type check to a type that does see the overridden accessor for global in AbstractPrinter