Add support for field accesses and constructors

Author: mbovel

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

@@ -472,7 +472,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   def New(tpt: Tree, argss: List[List[Tree]])(using Context): Tree =
     ensureApplied(argss.foldLeft(makeNew(tpt))(Apply(_, _)))
 
-  /** A new expression with constrictor and possibly type arguments. See
+  /** A new expression with constructor and possibly type arguments. See
    *  `New(tpt, argss)` for details.
    */
   def makeNew(tpt: Tree)(using Context): Tree = {

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

@@ -662,6 +662,7 @@ class Definitions {
   @tu lazy val StringClass: ClassSymbol = requiredClass("java.lang.String")
   def StringType: Type = StringClass.typeRef
   @tu lazy val StringModule: Symbol = StringClass.linkedClass
+    @tu lazy val String_== : TermSymbol = enterMethod(StringClass, nme.EQ, methOfAnyRef(BooleanType), Final)
     @tu lazy val String_+ : TermSymbol = enterMethod(StringClass, nme.raw.PLUS, methOfAny(StringType), Final)
     @tu lazy val String_valueOf_Object: Symbol = StringModule.info.member(nme.valueOf).suchThat(_.info.firstParamTypes match {
       case List(pt) => pt.isAny || pt.stripNull().isAnyRef

compiler/src/dotty/tools/dotc/qualified_types/EGraph.scala

@@ -2,6 +2,7 @@ package dotty.tools.dotc.qualified_types
 
 import scala.collection.mutable
 import scala.collection.mutable.ArrayBuffer
+import scala.collection.mutable.ListBuffer
 
 import dotty.tools.dotc.ast.tpd.{
   closureDef,
@@ -25,13 +26,16 @@ import dotty.tools.dotc.core.Constants.Constant
 import dotty.tools.dotc.core.Contexts.Context
 import dotty.tools.dotc.core.Contexts.ctx
 import dotty.tools.dotc.core.Decorators.i
+import dotty.tools.dotc.core.Flags
 import dotty.tools.dotc.core.Hashable.Binders
 import dotty.tools.dotc.core.Names.Designator
 import dotty.tools.dotc.core.StdNames.nme
 import dotty.tools.dotc.core.Symbols.{defn, NoSymbol, Symbol}
 import dotty.tools.dotc.core.Types.{
+  AppliedType,
   CachedProxyType,
   ConstantType,
+  LambdaType,
   MethodType,
   NamedType,
   NoPrefix,
@@ -40,14 +44,14 @@ import dotty.tools.dotc.core.Types.{
   TermParamRef,
   TermRef,
   Type,
+  TypeRef,
   TypeVar,
   ValueType
 }
 import dotty.tools.dotc.qualified_types.ENode.Op
 import dotty.tools.dotc.reporting.trace
 import dotty.tools.dotc.transform.TreeExtractors.BinaryOp
 import dotty.tools.dotc.util.Spans.Span
-import scala.collection.mutable.ListBuffer
 
 final class EGraph(rootCtx: Context):
 
@@ -92,7 +96,7 @@ final class EGraph(rootCtx: Context):
   private val builtinOps = Map(
     d.Int_== -> Op.Equal,
     d.Boolean_== -> Op.Equal,
-    d.Any_== -> Op.Equal,
+    d.String_== -> Op.Equal,
     d.Boolean_&& -> Op.And,
     d.Boolean_|| -> Op.Or,
     d.Boolean_! -> Op.Not,
@@ -108,9 +112,8 @@ final class EGraph(rootCtx: Context):
 
   def equiv(node1: ENode, node2: ENode)(using Context): Boolean =
     trace(i"EGraph.equiv", Printers.qualifiedTypes):
-      val margin = ctx.base.indentTab * (ctx.base.indent)
+      // val margin = ctx.base.indentTab * (ctx.base.indent)
       // println(s"$margin node1: $node1\n$margin node2: $node2")
-      // Check if the representents of both nodes are the same
       val repr1 = representent(node1)
       val repr2 = representent(node2)
       repr1 eq repr2
@@ -121,8 +124,8 @@ final class EGraph(rootCtx: Context):
         node match
           case ENode.Atom(tp) =>
             ()
-          case ENode.New(clazz) =>
-            addUse(clazz, node)
+          case ENode.Constructor(sym) =>
+            ()
           case ENode.Select(qual, member) =>
             addUse(qual, node)
           case ENode.Apply(fn, args) =>
@@ -138,6 +141,7 @@ final class EGraph(rootCtx: Context):
       }
     ).asInstanceOf[node.type]
 
+  // TODO(mbovel): Memoize this
   def toNode(tree: Tree, paramSyms: List[Symbol] = Nil, paramTps: List[ENode.ArgRefType] = Nil)(using
       Context
   ): Option[ENode] =
@@ -165,16 +169,18 @@ final class EGraph(rootCtx: Context):
       tree match
         case Literal(_) | Ident(_) | This(_) if tree.tpe.isInstanceOf[SingletonType] =>
           Some(ENode.Atom(mapType(tree.tpe).asInstanceOf[SingletonType]))
-        case New(clazz) =>
-          for clazzNode <- toNode(clazz, paramSyms, paramTps) yield ENode.New(clazzNode)
+        case Select(New(_), nme.CONSTRUCTOR) =>
+          constructorNode(tree.symbol)
+        case tree: Select if isCaseClassApply(tree.symbol) =>
+          constructorNode(tree.symbol.owner.linkedClass.primaryConstructor)
         case Select(qual, name) =>
-          for qualNode <- toNode(qual, paramSyms, paramTps) yield ENode.Select(qualNode, tree.symbol)
+          for qualNode <- toNode(qual, paramSyms, paramTps) yield normalizeSelect(qualNode, tree.symbol)
         case BinaryOp(lhs, op, rhs) if builtinOps.contains(op) =>
           for
             lhsNode <- toNode(lhs, paramSyms, paramTps)
             rhsNode <- toNode(rhs, paramSyms, paramTps)
           yield normalizeOp(builtinOps(op), List(lhsNode, rhsNode))
-        case BinaryOp(lhs, d.Int_-, rhs) if lhs.tpe.isInstanceOf[ValueType] && rhs.tpe.isInstanceOf[ValueType] =>
+        case BinaryOp(lhs, d.Int_-, rhs) =>
           for
             lhsNode <- toNode(lhs, paramSyms, paramTps)
             rhsNode <- toNode(rhs, paramSyms, paramTps)
@@ -192,7 +198,7 @@ final class EGraph(rootCtx: Context):
             case mt: MethodType =>
               assert(defDef.termParamss.size == 1, "closures have a single parameter list, right?")
               val myParamSyms: List[Symbol] = defDef.termParamss.head.map(_.symbol)
-              val myParamTps: ListBuffer[ENode.ArgRefType] =  ListBuffer.empty
+              val myParamTps: ListBuffer[ENode.ArgRefType] = ListBuffer.empty
               val paramTpsSize = paramTps.size
               for myParamSym <- myParamSyms do
                 val underlying = mapType(myParamSym.info.subst(myParamSyms.take(myParamTps.size), myParamTps.toList))
@@ -204,15 +210,38 @@ final class EGraph(rootCtx: Context):
         case _ =>
           None
 
+  // TODO(mbovel): Memoize this
+  private def constructorNode(constr: Symbol)(using Context): Option[ENode.Constructor] =
+    val clazz = constr.owner
+    if hasStructuralEquality(clazz) then
+      val isPrimaryConstructor = constr.denot.isPrimaryConstructor
+      val fieldsRaw = clazz.denot.asClass.paramAccessors.filter(isPrimaryConstructor && _.isStableMember)
+      val constrParams = constr.paramSymss.flatten.filter(_.isTerm)
+      val fields = constrParams.map(p => fieldsRaw.find(_.name == p.name).getOrElse(NoSymbol))
+      Some(ENode.Constructor(constr)(fields))
+    else
+      None
+
+  private def hasStructuralEquality(clazz: Symbol)(using Context): Boolean =
+    val equalsMethod = clazz.info.decls.lookup(nme.equals_)
+    val equalsNotOverriden = !equalsMethod.exists || equalsMethod.is(Flags.Synthetic)
+    clazz.isClass && clazz.is(Flags.Case) && equalsNotOverriden
+
+  private def isCaseClassApply(meth: Symbol)(using Context): Boolean =
+    meth.name == nme.apply
+      && meth.flags.is(Flags.Synthetic)
+      && meth.owner.linkedClass.is(Flags.Case)
+
   private def canonicalize(node: ENode): ENode =
+    // println(s"canonicalize $node")
     representent(unique(
       node match
         case ENode.Atom(tp) =>
           node
-        case ENode.New(clazz) =>
-          ENode.New(representent(clazz))
+        case ENode.Constructor(sym) =>
+          node
         case ENode.Select(qual, member) =>
-          ENode.Select(representent(qual), member)
+          normalizeSelect(representent(qual), member)
         case ENode.Apply(fn, args) =>
           ENode.Apply(representent(fn), args.map(representent))
         case ENode.OpApply(op, args) =>
@@ -223,6 +252,33 @@ final class EGraph(rootCtx: Context):
           ENode.Lambda(paramTps, retTp, representent(body))
     ))
 
+  private def normalizeSelect(qual: ENode, member: Symbol): ENode =
+    getAppliedConstructor(qual) match
+      case Some(constr) =>
+        val memberIndex = constr.fields.indexOf(member)
+
+        if memberIndex >= 0 then
+          val args = getTermArguments(qual)
+          assert(args.size == constr.fields.size)
+          args(memberIndex)
+        else
+          ENode.Select(qual, member)
+      case None =>
+        ENode.Select(qual, member)
+
+  private def getAppliedConstructor(node: ENode): Option[ENode.Constructor] =
+    node match
+      case ENode.Apply(fn, args)     => getAppliedConstructor(fn)
+      case ENode.TypeApply(fn, args) => getAppliedConstructor(fn)
+      case node: ENode.Constructor   => Some(node)
+      case _                         => None
+
+  private def getTermArguments(node: ENode): List[ENode] =
+    node match
+      case ENode.Apply(fn, args)     => getTermArguments(fn) ::: args
+      case ENode.TypeApply(fn, args) => getTermArguments(fn)
+      case _                         => Nil
+
   private def normalizeOp(op: ENode.Op, args: List[ENode]): ENode =
     op match
       case Op.Equal =>
@@ -316,12 +372,10 @@ final class EGraph(rootCtx: Context):
     (a, b) match
       case (ENode.Atom(_: ConstantType), _) => (a, b)
       case (_, ENode.Atom(_: ConstantType)) => (b, a)
-      case (ENode.Atom(_: SkolemType), _)   => (a, b)
-      case (_, ENode.Atom(_: SkolemType))   => (b, a)
+      case (_: ENode.Constructor, _)        => (a, b)
+      case (_, _: ENode.Constructor)        => (b, a)
       case (_: ENode.Atom, _)               => (a, b)
       case (_, _: ENode.Atom)               => (b, a)
-      case (_: ENode.New, _)                => (a, b)
-      case (_, _: ENode.New)                => (b, a)
       case (_: ENode.Select, _)             => (a, b)
       case (_, _: ENode.Select)             => (b, a)
       case (_: ENode.Apply, _)              => (a, b)
@@ -336,8 +390,6 @@ final class EGraph(rootCtx: Context):
     if aRepr eq bRepr then return
     assert(aRepr != bRepr, s"$aRepr and $bRepr are `equals` but not `eq`")
 
-    // TODO(mbovel): if both nodes are objects, recursively merge their arguments
-
     /// Update represententOf and usedBy maps
     val (newRepr, oldRepr) = order(aRepr, bRepr)
     represententOf(oldRepr) = newRepr
@@ -371,8 +423,9 @@ final class EGraph(rootCtx: Context):
     node match
       case ENode.Atom(tp) =>
         singleton(tp)
-      case ENode.New(clazz) =>
-        New(toTree(clazz, paramRefs))
+      case ENode.Constructor(sym) =>
+        val tycon = sym.owner.info.typeConstructor
+        New(tycon).select(TermRef(tycon, sym))
       case ENode.Select(qual, member) =>
         toTree(qual, paramRefs).select(member)
       case ENode.Apply(fn, args) =>

compiler/src/dotty/tools/dotc/qualified_types/ENode.scala

@@ -23,7 +23,7 @@ enum ENode:
   import ENode.*
 
   case Atom(tp: SingletonType)
-  case New(clazz: ENode)
+  case Constructor(constr: Symbol)(val fields: List[Symbol])
   case Select(qual: ENode, member: Symbol)
   case Apply(fn: ENode, args: List[ENode])
   case OpApply(fn: ENode.Op, args: List[ENode])
@@ -33,7 +33,7 @@ enum ENode:
   override def toString(): String =
     this match
       case Atom(tp)             => typeToString(tp)
-      case New(clazz)           => s"new $clazz"
+      case Constructor(constr)  => s"new ${designatorToString(constr.lastKnownDenotation.owner)}"
       case Select(qual, member) => s"$qual.${designatorToString(member)}"
       case Apply(fn, args)      => s"$fn(${args.mkString(", ")})"
       case OpApply(op, args)    => s"(${args.mkString(op.operatorString())})"

compiler/src/dotty/tools/dotc/qualified_types/QualifierSolver.scala

@@ -53,10 +53,10 @@ class QualifierSolver(using Context):
       case _ => ()
 
     val egraph = EGraph(ctx)
-    //println(s"tree implies $tree1 -> $tree2")
+    // println(s"tree implies $tree1 -> $tree2")
     (egraph.toNode(QualifierEvaluator.evaluate(tree1)), egraph.toNode(QualifierEvaluator.evaluate(tree2))) match
       case (Some(node1), Some(node2)) =>
-        //println(s"node implies $node1 -> $node2")
+        // println(s"node implies $node1 -> $node2")
         egraph.merge(node1, egraph.trueNode)
         egraph.repair()
         egraph.equiv(node2, egraph.trueNode)

tests/neg-custom-args/qualified-types/adapt_neg.scala

@@ -12,11 +12,11 @@ def test: Unit =
   val v3: {v: Int with v == x + 1} = x + 2 // error
   val v4: {v: Int with v == f(x)} = g(x) // error
   val v5: {v: Int with v == g(x)} = f(x) // error
-  //val v6: {v: Int with v == IntBox(x)} = IntBox(x) // Not implemented
-  //val v7: {v: Int with v == Box(x)} = Box(x) // Not implemented
+  val v6: {v: IntBox with v == IntBox(x)} = IntBox(x + 1) // error
+  val v7: {v: Box[Int] with v == Box(x)} = Box(x + 1) // error
   val v8: {v: Int with v == x + f(x)} = x + g(x) // error
   val v9: {v: Int with v == x + g(x)} = x + f(x) // error
   val v10: {v: Int with v == f(x + 1)} = f(x + 2) // error
   val v11: {v: Int with v == g(x + 1)} = g(x + 2) // error
-  //val v12: {v: Int with v == IntBox(x + 1)} = IntBox(x + 1) // Not implemented
-  //val v13: {v: Int with v == Box(x + 1)} = Box(x + 1) // Not implemented
+  val v12: {v: IntBox with v == IntBox(x + 1)} = IntBox(x) // error
+  val v13: {v: Box[Int] with v == Box(x + 1)} = Box(x) // error

tests/neg-custom-args/qualified-types/subtyping_objects_neg.scala

@@ -0,0 +1,52 @@
+class Box[T](val x: T)
+
+class BoxMutable[T](var x: T)
+
+class Foo(val id: String):
+  def this(x: Int) = this(x.toString)
+
+class Person(val name: String, val age: Int)
+
+class PersonCurried(val name: String)(val age: Int)
+
+class PersonMutable(val name: String, var age: Int)
+
+case class PersonCaseMutable(name: String, var age: Int)
+
+case class PersonCaseSecondary(name: String, age: Int):
+  def this(name: String) = this(name, 0)
+
+case class PersonCaseEqualsOverriden(name: String, age: Int):
+  override def equals(that: Object): Boolean = this eq that
+
+def test: Unit =
+  summon[{b: Box[Int] with b == Box(1)} =:= {b: Box[Int] with b == Box(1)}] // error
+
+  summon[{b: BoxMutable[Int] with b == BoxMutable(1)} =:= {b: BoxMutable[Int] with b == BoxMutable(1)}] // error
+  // TODO(mbovel): restrict selection to stable members
+  //summon[{b: BoxMutable[Int] with b.x == 3} =:= {b: BoxMutable[Int] with b.x == 3}]
+
+  summon[{f: Foo with f == Foo("hello")} =:= {f: Foo with f == Foo("hello")}] // error
+  summon[{f: Foo with f == Foo(1)} =:= {f: Foo with f == Foo(1)}] // error
+  summon[{s: String with Foo("hello").id == s} =:= {s: String with s == "hello"}] // error
+
+  summon[{p: Person with p == Person("Alice", 30)} =:= {p: Person with p == Person("Alice", 30)}] // error
+  summon[{s: String with Person("Alice", 30).name == s} =:= {s: String with s == "Alice"}] // error
+  summon[{n: Int with Person("Alice", 30).age == n} =:= {n: Int with n == 30}] // error
+
+  summon[{p: PersonCurried with p == PersonCurried("Alice")(30)} =:= {p: PersonCurried with p == PersonCurried("Alice")(30)}] // error
+  summon[{s: String with PersonCurried("Alice")(30).name == s} =:= {s: String with s == "Alice"}] // error
+  summon[{n: Int with PersonCurried("Alice")(30).age == n} =:= {n: Int with n == 30}] // error
+
+  summon[{p: PersonMutable with p == PersonMutable("Alice", 30)} =:= {p: PersonMutable with p == PersonMutable("Alice", 30)}] // error
+  summon[{s: String with PersonMutable("Alice", 30).name == s} =:= {s: String with s == "Alice"}] // error
+  summon[{n: Int with PersonMutable("Alice", 30).age == n} =:= {n: Int with n == 30}] // error
+
+  summon[{n: Int with PersonCaseMutable("Alice", 30).age == n} =:= {n: Int with n == 30}] // error
+
+  summon[{s: String with new PersonCaseSecondary("Alice").name == s} =:= {s: String with s == "Alice"}] // error
+  summon[{n: Int with new PersonCaseSecondary("Alice").age == n} =:= {n: Int with n == 0}] // error
+
+  summon[{p: PersonCaseEqualsOverriden with PersonCaseEqualsOverriden("Alice", 30) == p} =:= {p: PersonCaseEqualsOverriden with p == PersonCaseEqualsOverriden("Alice", 30)}] // error
+  summon[{s: String with PersonCaseEqualsOverriden("Alice", 30).name == s} =:= {s: String with s == "Alice"}] // error
+  summon[{n: Int with PersonCaseEqualsOverriden("Alice", 30).age == n} =:= {n: Int with n == 30}] // error

tests/pos-custom-args/qualified-types/adapt.scala

@@ -2,7 +2,6 @@ def f(x: Int): Int = ???
 case class IntBox(x: Int)
 case class Box[T](x: T)
 
-
 def f(x: Int, y: Int): {r: Int with r == x + y} = x + y
 
 def test: Unit =
@@ -12,11 +11,11 @@ def test: Unit =
   val v1: {v: Int with v == x + 1} = x + 1
   val v2: {v: Int with v == f(x)} = f(x)
   val v3: {v: Int with v == g(x)} = g(x)
-  //val v6: {v: Int with v == IntBox(x)} = IntBox(x) // Not implemented
-  //val v7: {v: Int with v == Box(x)} = Box(x) // Not implemented
-  val v4: {v: Int with v == x + f(x)} = x + f(x)
-  val v5: {v: Int with v == x + g(x)} = x + g(x)
-  val v6: {v: Int with v == f(x + 1)} = f(x + 1)
-  val v7: {v: Int with v == g(x + 1)} = g(x + 1)
-  //val v12: {v: Int with v == IntBox(x + 1)} = IntBox(x + 1) // Not implemented
-  //val v13: {v: Int with v == Box(x + 1)} = Box(x + 1) // Not implemented
+  val v4: {v: IntBox with v == IntBox(x)} = IntBox(x)
+  val v5: {v: Box[Int] with v == Box(x)} = Box(x)
+  val v6: {v: Int with v == x + f(x)} = x + f(x)
+  val v7: {v: Int with v == x + g(x)} = x + g(x)
+  val v8: {v: Int with v == f(x + 1)} = f(x + 1)
+  val v9: {v: Int with v == g(x + 1)} = g(x + 1)
+  val v12: {v: IntBox with v == IntBox(x + 1)} = IntBox(x + 1)
+  val v13: {v: Box[Int] with v == Box(x + 1)} = Box(x + 1)

tests/pos-custom-args/qualified-types/sized_lists.scala

@@ -1,9 +1,6 @@
-
-
 def size(v: Vec): Int = ???
 type Vec
 
-
 def vec(s: Int): {v: Vec with size(v) == s} = ???
 def concat(v1: Vec, v2: Vec): {v: Vec with size(v) == size(v1) + size(v2)} = ???
 def sum(v1: Vec, v2: Vec with size(v1) == size(v2)): {v: Vec with size(v) == size(v1)} = ???