`mkAttributedQualifier(_1.type, <none>)` compiler crash

[soronpo]

It took long to minimize 😢
Here is the code that demonstrates two bugs: an error and a compiler crash (see the comments at the end).

package DFiant

object Extras {
  type <>[DF <: DFAny, Dir <: DFDir] = DFAny.Port[DF, Dir] with DF
  //Direction of a Port
  sealed trait DFDir
  sealed trait IN extends DFDir
  implicit object IN extends IN
  sealed trait OUT extends DFDir
  implicit object OUT extends OUT
  ////////////////////////////////////////////////////////////////////////////////////
}

import Extras._

class IfWithRetVal[RV <: DFAny, Builder[L, R] <: DFAny.Op.Builder[L, R]] {
  protected[DFiant] class DFIfBlock(val cond : Boolean, block : => RV) {
    def elsedf[R](elseBlock: => Unit)(implicit op : Builder[RV, R]) : RV = ???
  }
  def apply[R](cond: Boolean)(block: => Unit)(implicit op : Builder[RV, R]) : DFIfBlock = ???
}

trait DFAny {
  type TVal <: DFAny.Unbounded[TCompanion]
  type TCompanion <: DFAny.Companion
  type TUnbounded = protComp.Unbounded
  protected[DFiant] val protComp : TCompanion
}



object DFAny {
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
  // Head Types
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
  trait Unbounded[T <: DFAny.Companion] extends DFAny {
    type TCompanion = T
  }

  trait Var extends DFAny {
    final def <> [RDIR <: DFDir](right: TVal <> RDIR) : Unit = ???
  }

  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////


  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
  // Abstract Constructors
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
  abstract class NewVar[DF <: DFAny](
    implicit cmp : Companion
  ) extends DFAny.Var {
    final protected[DFiant] lazy val protComp : TCompanion = cmp.asInstanceOf[TCompanion]
    def <> [Dir <: DFDir](dir : Dir)(implicit port : protComp.Port.Builder[TVal, Dir]) : Unit = {}
    final object ifdf extends IfWithRetVal[TVal, protComp.`Op:=`.Builder]
  }
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////


  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
  // Port
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
  abstract class Port[DF <: DFAny, Dir <: DFDir](dfVar : DF, val dir : Dir)(
    implicit cmp : Companion
  ) extends DFAny.Var {
    final protected[DFiant] lazy val protComp : TCompanion = cmp.asInstanceOf[TCompanion]
  }
  object Port {
    trait Builder[L <: DFAny, Dir <: DFDir] {
      def apply(right : L, dir : Dir) : Unit
    }
  }
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////

  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
  // Op
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
  object Op {
    trait Builder[L, R] {
      type Comp <: DFAny
      def apply(left : L, rightR : R) : Comp
    }
  }
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////


  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
  // Create Companion object of DFXXX extenders of DFAny
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
  trait Companion {
    type Unbounded <: DFAny.Unbounded[this.type]

    /////////////////////////////////////////////////////////////////////////////////////////////////////////////
    // Port
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////
    trait PortCO {
      type Builder[L <: DFAny, Dir <: DFDir] <: DFAny.Port.Builder[L, Dir]
    }
    val Port : PortCO
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////

    /////////////////////////////////////////////////////////////////////////////////////////////////////////////
    // Common Ops
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////
    trait `Op:=` {
      type Builder[L, R] <: DFAny.Op.Builder[L, R]
    }
    val `Op:=` : `Op:=`
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////

    implicit val cmp = this
  }
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////

}


trait DFBits extends DFBits.Unbounded {
}


object DFBits extends DFAny.Companion {
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
  // Unbounded Val
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
  trait Unbounded extends DFAny.Unbounded[DFBits.type] {
    type TVal = DFBits
  }
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////

  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
  // Var
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
  trait Var extends DFBits with DFAny.Var {
  }
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////


  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
  // Public Constructors
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
  def apply() : NewVar = ???
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////


  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
  // Protected Constructors
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
  protected[DFiant] final class NewVar extends DFAny.NewVar[DFBits] with Var {}
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////

  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
  // Port
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
  object Port extends PortCO {
    trait Builder[L <: DFAny, Dir <: DFDir] extends DFAny.Port.Builder[L, Dir]
    object Builder {
      implicit def conn[LW, Dir <: DFDir]
      : Builder[DFBits, Dir] = ???
    }
  }
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////

  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
  // Assign & Connect
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
  trait `Ops:=,<>` extends `Op:=` {
    @scala.annotation.implicitNotFound("Dataflow variable ${L} does not support assignment/connect operation with the type ${R}")
    trait Builder[L, R] extends DFAny.Op.Builder[L, R]

    object Builder {
      type Aux[L, R, Comp0] = Builder[L, R] {
        type Comp = Comp0
      }

      implicit def evDFBits_op_DFBits[LW, RW] : Aux[DFBits, DFBits, DFBits] = ???
    }
  }
  object `Op:=` extends `Ops:=,<>`
  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
}

trait Bugs {
  val bug1 = DFBits() <> IN //error: does not take parameters
  val bug2 = DFBits().ifdf(true) {} elsedf {} //compiler crash: mkAttributedQualifier(_1.type, <none>)

  val workaround = DFBits()
  val ok1 = workaround <> IN
  val ok2 = workaround.ifdf(true) {} elsedf {}
}

[SethTisue]

this isn't standalone code — it chokes on protected[DFiant], since DFiant isn't defined

it's also difficult to believe that it can't be minimized much more than this — it's extremely rare that any bug requires so much code to demonstrate it

we'd want separate reports with separate minimizations on the error and the crash, unless you can show that they are inextricably related

[soronpo]

Why close the issue @SethTisue ?

[SethTisue]

for the reasons I stated, and because it's highly unlikely to progress without a minimization

(regardless, the closed issue will turn up in searches and discussion remains possible here; the ticket isn't annihilated, merely closed; and closed tickets can be reopened, even)

[SethTisue]

The most immediate reason I closed it is that isn't even reproducible. I cannot compile this code to see if it crashes Scala 2.13.10 or not, or if Scala 3 compiles it.

[soronpo]

Look, this is the first feedback I got on that bug report after almost 5 years. Maybe it was a small mistake and that can be mitigated, maybe now, after accumulating the 5-year knowledge, I can further minimize the bug. Closing this suddenly without first inquiring is a total disregard for the time spent in minimizing and submitting the ticket (could even have been days of work). Very disappointing.

[som-snytt]

it crashes after the error.

Just slapping package DFiant lets it crash in more pure fashion.

[SethTisue]

Maybe it was a small mistake and that can be mitigated, maybe now, after accumulating the 5-year knowledge, I can further minimize the bug

Indeed, and if that happens, we'd be more than happy to reopen the ticket.

The open/closed bit on a ticket is just that: a bit. Flipping it is a single mouse click, and flipping it again is another mouse click.

Very disappointing.

I assume you meant well in your original report. I ask you to assume that I also mean well; because I do.

[SethTisue]

related: our previous discussion at scala/scala-dev#577

[soronpo]

related: our previous discussion at scala/scala-dev#577

The arguments pro/con closing an old issue ticket is different than PRs.
This is literally sweeping bugs under the (closed ticket) carpet, and with total disregard to the efforts, well intentioned or not.
The bug exists, is reproduceable, as @som-snytt demonstrated, and has zero dependencies.
Want it minimized further? put a flag on it that the ticket requires further minimization.
Keep under backlog forever, for all I care. But if someone else wastes their time minimizing and re-reporting the same bug just because this ticket is closed, that's on you.
Closing it achieves less benefit to the community than keeping it open for visibility.

[SethTisue]

I've added the "needs info" label. We don't have a more specific label than that, but we're free to get more specific in the comments. (I've already done so, above.)

I'm reopening the ticket. But I'm doing it not because I agree with your remarks, but because Som says he was able to reproduce it and he told us how. I've edited the code at the top of the report to include the required package declaration.

perhaps related: #10636