Encode qualifier arguments as E-Nodes

Author: mbovel

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

@@ -2562,7 +2562,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

@@ -617,9 +617,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

@@ -889,7 +889,10 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
             throw ex
         compareCapturing || fourthTry
       case QualifiedType(parent2, qualifier2) =>
-        QualifiedTypes.typeImplies(tp1, qualifier2) && recur(tp1, parent2)
+        val parentSub = recur(tp1, parent2)
+        val qualifierSub = QualifiedTypes.typeImplies(tp1, qualifier2)
+        //println(i"compare qualified $tp1 <:< $tp2, parentSub = $parentSub, qualifierSub = $qualifierSub")
+        parentSub && qualifierSub
       case tp2: AnnotatedType if tp2.isRefining =>
         (tp1.derivesAnnotWith(tp2.annot.sameAnnotation) || tp1.isBottomType) &&
         recur(tp1, tp2.parent)

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
 
@@ -5884,7 +5884,8 @@ object Types extends TypeUtils {
     def make(underlying: Type, annots: List[Annotation])(using Context): Type =
       annots.foldLeft(underlying)(apply(_, _))
     def apply(parent: Type, annot: Annotation)(using Context): AnnotatedType =
-      unique(CachedAnnotatedType(parent, annot))
+      val annot1 = if annot.symbol == defn.QualifiedAnnot then QualifiedAnnotation(annot) else annot
+      unique(CachedAnnotatedType(parent, annot1))
   end AnnotatedType
 
   // Special type objects and classes -----------------------------------------------------

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

@@ -1659,7 +1659,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/qualified_types/ArgRefType.scala

@@ -0,0 +1,20 @@
+package dotty.tools.dotc.qualified_types
+import dotty.tools.dotc.core.Types.{
+  SingletonType,
+  CachedProxyType,
+  Type
+}
+import dotty.tools.dotc.core.Contexts.Context
+import dotty.tools.dotc.core.Hashable.Binders
+
+
+/** Reference to the argument of an [[ENode.Lambda]].
+ *
+ *  @param index 
+ *    Debruijn index of the argument, starting from 0
+ *  @param underyling
+ *    Underlying type of the argument
+ */
+final case class ENodeParamRef(index: Int, underlying: Type) extends CachedProxyType, SingletonType:
+  override def underlying(using Context): Type = underlying
+  override def computeHash(bs: Binders): Int = doHash(bs, index, underlying)