Encode qualifier arguments as E-Nodes

Author: mbovel

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -2559,7 +2559,8 @@ object desugar {
           tree
 
     if Feature.qualifiedTypesEnabled then
-      transform(tpt)
+      trace(i"desugar qualified types in pattern: $tpt", Printers.qualifiedTypes):
+        transform(tpt)
     else
       tpt
 

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -625,9 +625,11 @@ class Definitions {
     @tu lazy val Int_/  : Symbol = IntClass.requiredMethod(nme.DIV, List(IntType))
     @tu lazy val Int_*  : Symbol = IntClass.requiredMethod(nme.MUL, List(IntType))
     @tu lazy val Int_== : Symbol = IntClass.requiredMethod(nme.EQ, List(IntType))
+    @tu lazy val Int_!= : Symbol = IntClass.requiredMethod(nme.NE, List(IntType))
     @tu lazy val Int_>= : Symbol = IntClass.requiredMethod(nme.GE, List(IntType))
     @tu lazy val Int_<= : Symbol = IntClass.requiredMethod(nme.LE, List(IntType))
     @tu lazy val Int_>  : Symbol = IntClass.requiredMethod(nme.GT, List(IntType))
+    @tu lazy val Int_<  : Symbol = IntClass.requiredMethod(nme.LT, List(IntType))
   @tu lazy val LongType: TypeRef = valueTypeRef("scala.Long", java.lang.Long.TYPE, LongEnc, nme.specializedTypeNames.Long)
   def LongClass(using Context): ClassSymbol = LongType.symbol.asClass
     @tu lazy val Long_+ : Symbol = LongClass.requiredMethod(nme.PLUS, List(LongType))

compiler/src/dotty/tools/dotc/core/TypeComparer.scala

@@ -888,7 +888,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
             throw ex
         compareCapturing || fourthTry
       case QualifiedType(parent2, qualifier2) =>
-        QualifiedTypes.typeImplies(tp1, qualifier2) && recur(tp1, parent2)
+        recur(tp1, parent2) && QualifiedTypes.typeImplies(tp1, qualifier2, qualifierSolver())
       case tp2: AnnotatedType if tp2.isRefining =>
         (tp1.derivesAnnotWith(tp2.annot.sameAnnotation) || tp1.isBottomType) &&
         recur(tp1, tp2.parent)
@@ -3309,6 +3309,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
 
   protected def explainingTypeComparer(short: Boolean) = ExplainingTypeComparer(comparerContext, short)
   protected def matchReducer = MatchReducer(comparerContext)
+  protected def qualifierSolver() = qualified_types.QualifierSolver(using comparerContext)
 
   private def inSubComparer[T, Cmp <: TypeComparer](comparer: Cmp)(op: Cmp => T): T =
     val saved = myInstance
@@ -3974,7 +3975,7 @@ class ExplainingTypeComparer(initctx: Context, short: Boolean) extends TypeCompa
       lastForwardGoal = null
 
   override def traceIndented[T](str: String)(op: => T): T =
-    val str1 = str.replace('\n', ' ')
+    val str1 = str
     if short && str1 == lastForwardGoal then
       op // repeated goal, skip for clarity
     else
@@ -4043,5 +4044,9 @@ class ExplainingTypeComparer(initctx: Context, short: Boolean) extends TypeCompa
       super.subCaptures(refs1, refs2, vs)
     }
 
+  override def qualifierSolver() =
+    val traceIndented0 = [T] => (message: String) => traceIndented[T](message)
+    qualified_types.ExplainingQualifierSolver(traceIndented0)(using comparerContext)
+
   def lastTrace(header: String): String = header + { try b.toString finally b.clear() }
 }

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -41,7 +41,7 @@ import compiletime.uninitialized
 import cc.*
 import CaptureSet.IdentityCaptRefMap
 import Capabilities.*
-import qualified_types.QualifiedType
+import qualified_types.{QualifiedType, QualifiedAnnotation}
 import scala.annotation.internal.sharable
 import scala.annotation.threadUnsafe
 
@@ -6271,6 +6271,8 @@ object Types extends TypeUtils {
       tp.derivedAnnotatedType(underlying, annot)
     protected def derivedCapturingType(tp: Type, parent: Type, refs: CaptureSet): Type =
       tp.derivedCapturingType(parent, refs)
+    protected def derivedENodeParamRef(tp: qualified_types.ENodeParamRef, index: Int, underlying: Type): Type =
+      tp.derivedENodeParamRef(index, underlying)
     protected def derivedWildcardType(tp: WildcardType, bounds: Type): Type =
       tp.derivedWildcardType(bounds)
     protected def derivedSkolemType(tp: SkolemType, info: Type): Type =
@@ -6483,6 +6485,9 @@ object Types extends TypeUtils {
         case tp: JavaArrayType =>
           derivedJavaArrayType(tp, this(tp.elemType))
 
+        case tp: qualified_types.ENodeParamRef =>
+          derivedENodeParamRef(tp, tp.index, this(tp.underlying))
+
         case _ =>
           tp
       }

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -1664,7 +1664,7 @@ object Parsers {
      *                   |  `(' [ FunArgType {`,' FunArgType } ] `)'
      *                   |  '(' [ TypedFunParam {',' TypedFunParam } ')'
      *  MatchType      ::=  InfixType `match` <<< TypeCaseClauses >>>
-     *  QualifiedType2 ::=  InfixType `with` PostfixExprf
+     *  QualifiedType2 ::=  InfixType `with` PostfixExpr
      *  IntoType       ::=  [‘into’] IntoTargetType
      *                   |  ‘( IntoType ‘)’
      *  IntoTargetType ::=  Type

compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala

@@ -469,6 +469,11 @@ class PlainPrinter(_ctx: Context) extends Printer {
           "<" ~ reprStr ~ ":" ~ toText(tp.info) ~ ">"
         else
           reprStr
+      case qualified_types.ENodeParamRef(index, underlying) =>
+        if ctx.settings.XprintTypes.value then
+          "<" ~ "eparam" ~ index.toString ~ ":" ~ toText(underlying) ~ ">"
+        else
+          "eparam" ~ index.toString
     }
   }