Skip to content

Commit 883f383

Browse files
dwijnanddwijnand
committed
Implement GadtExpr
1 parent bfa32a4 commit 883f383

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

53 files changed

+463
-191
lines changed

‎compiler/src/dotty/tools/backend/jvm/BCodeBodyBuilder.scala

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -441,6 +441,10 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
441441
genBlockTo(blck, expectedType, dest)
442442
generatedDest = dest
443443

444+
case GadtExpr(_, expr) =>
445+
genLoadTo(expr, expectedType, dest)
446+
generatedDest = dest
447+
444448
case Typed(Super(_, _), _) =>
445449
genLoadTo(tpd.This(claszSymbol.asClass), expectedType, dest)
446450
generatedDest = dest

‎compiler/src/dotty/tools/backend/sjs/JSCodeGen.scala

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1851,6 +1851,9 @@ class JSCodeGen()(using genCtx: Context) {
18511851
}
18521852
js.Block(genStatsAndExpr)
18531853

1854+
case GadtExpr(_, expr) =>
1855+
genExpr(expr)
1856+
18541857
case Typed(expr, _) =>
18551858
expr match {
18561859
case _: Super => genThis()

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

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -336,6 +336,8 @@ object desugar {
336336
// Propagate down the expected type to the leafs of the expression
337337
case Block(stats, expr) =>
338338
cpy.Block(tree)(stats, adaptToExpectedTpt(expr))
339+
case GadtExpr(gadt, expr) =>
340+
cpy.GadtExpr(tree)(gadt, adaptToExpectedTpt(expr))
339341
case If(cond, thenp, elsep) =>
340342
cpy.If(tree)(cond, adaptToExpectedTpt(thenp), adaptToExpectedTpt(elsep))
341343
case untpd.Parens(expr) =>
@@ -1630,6 +1632,7 @@ object desugar {
16301632
case Tuple(trees) => (pats corresponds trees)(isIrrefutable)
16311633
case Parens(rhs1) => matchesTuple(pats, rhs1)
16321634
case Block(_, rhs1) => matchesTuple(pats, rhs1)
1635+
case GadtExpr(_, rhs1) => matchesTuple(pats, rhs1)
16331636
case If(_, thenp, elsep) => matchesTuple(pats, thenp) && matchesTuple(pats, elsep)
16341637
case Match(_, cases) => cases forall (matchesTuple(pats, _))
16351638
case CaseDef(_, _, rhs1) => matchesTuple(pats, rhs1)

‎compiler/src/dotty/tools/dotc/ast/TreeInfo.scala

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -309,6 +309,7 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
309309
case If(_, thenp, elsep) => forallResults(thenp, p) && forallResults(elsep, p)
310310
case Match(_, cases) => cases forall (c => forallResults(c.body, p))
311311
case Block(_, expr) => forallResults(expr, p)
312+
case GadtExpr(_, expr) => forallResults(expr, p)
312313
case _ => p(tree)
313314
}
314315
}
@@ -1039,6 +1040,7 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
10391040
case Typed(expr, _) => unapply(expr)
10401041
case Inlined(_, Nil, expr) => unapply(expr)
10411042
case Block(Nil, expr) => unapply(expr)
1043+
case GadtExpr(_, expr) => unapply(expr)
10421044
case _ =>
10431045
tree.tpe.widenTermRefExpr.normalized match
10441046
case ConstantType(Constant(x)) => Some(x)

‎compiler/src/dotty/tools/dotc/ast/TreeTypeMap.scala

Lines changed: 35 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -123,6 +123,18 @@ class TreeTypeMap(
123123
cpy.Block(blk)(stats1, expr1)
124124
case inlined: Inlined =>
125125
transformInlined(inlined)
126+
case GadtExpr(gadt, expr) =>
127+
cpy.GadtExpr(expr)(gadt, transform(expr))
128+
case cdef @ CaseDef(pat, guard, expr @ GadtExpr(gadt, rhs)) =>
129+
val patVars1 = patVars(pat)
130+
val tmap = withMappedSyms(patVars1 ::: gadt.symbols.diff(substFrom).diff(patVars1))
131+
val gadt1 = tmap.rebuild(gadt)
132+
inContext(ctx.withGadt(gadt1)) {
133+
val pat1 = tmap.transform(pat)
134+
val guard1 = tmap.transform(guard)
135+
val rhs1 = cpy.GadtExpr(expr)(gadt1, tmap.transform(rhs))
136+
cpy.CaseDef(cdef)(pat1, guard1, rhs1)
137+
}
126138
case cdef @ CaseDef(pat, guard, rhs) =>
127139
val tmap = withMappedSyms(patVars(pat))
128140
val pat1 = tmap.transform(pat)
@@ -146,6 +158,29 @@ class TreeTypeMap(
146158
}
147159
}
148160

161+
private def rebuild(gadt: GadtConstraint)(using Context): GadtConstraint =
162+
val constraints = for sym <- gadt.symbols yield
163+
val TypeBounds(lo, hi) = gadt.fullBounds(sym).nn
164+
(sym, lo, hi)
165+
val constraints1 = constraints.mapConserve { triple =>
166+
val (sym, lo, hi) = triple
167+
val sym1 = mapOwner(sym)
168+
val lo1 = mapType(lo)
169+
val hi1 = mapType(hi)
170+
if (sym eq sym1) && (lo eq lo1) && (hi eq hi1)
171+
then triple
172+
else (sym1, lo1, hi1)
173+
}
174+
if constraints eq constraints1 then
175+
gadt
176+
else
177+
val gadt = EmptyGadtConstraint.fresh
178+
for (sym, lo, hi) <- constraints1 do
179+
gadt.addToConstraint(sym)
180+
gadt.addBound(sym, lo, false)
181+
gadt.addBound(sym, hi, true)
182+
gadt
183+
149184
override def transformStats(trees: List[tpd.Tree], exprOwner: Symbol)(using Context): List[Tree] =
150185
transformDefs(trees)._2
151186

‎compiler/src/dotty/tools/dotc/ast/Trees.scala

Lines changed: 18 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -569,6 +569,12 @@ object Trees {
569569
override def isTerm: Boolean = !isType // this will classify empty trees as terms, which is necessary
570570
}
571571

572+
case class GadtExpr[-T >: Untyped] private[ast] (gadt: GadtConstraint, expr: Tree[T])(implicit @constructorOnly src: SourceFile)
573+
extends ProxyTree[T] {
574+
type ThisTree[-T >: Untyped] <: GadtExpr[T]
575+
def forwardTo: Tree[T] = expr
576+
}
577+
572578
/** if cond then thenp else elsep */
573579
case class If[-T >: Untyped] private[ast] (cond: Tree[T], thenp: Tree[T], elsep: Tree[T])(implicit @constructorOnly src: SourceFile)
574580
extends TermTree[T] {
@@ -1071,6 +1077,7 @@ object Trees {
10711077
type NamedArg = Trees.NamedArg[T]
10721078
type Assign = Trees.Assign[T]
10731079
type Block = Trees.Block[T]
1080+
type GadtExpr = Trees.GadtExpr[T]
10741081
type If = Trees.If[T]
10751082
type InlineIf = Trees.InlineIf[T]
10761083
type Closure = Trees.Closure[T]
@@ -1209,6 +1216,9 @@ object Trees {
12091216
case tree: Block if (stats eq tree.stats) && (expr eq tree.expr) => tree
12101217
case _ => finalize(tree, untpd.Block(stats, expr)(sourceFile(tree)))
12111218
}
1219+
def GadtExpr(tree: Tree)(gadt: GadtConstraint, expr: Tree)(using Context): GadtExpr = tree match
1220+
case tree: GadtExpr if (gadt eq tree.gadt) && (expr eq tree.expr) => tree
1221+
case _ => finalize(tree, untpd.GadtExpr(gadt, expr)(sourceFile(tree)))
12121222
def If(tree: Tree)(cond: Tree, thenp: Tree, elsep: Tree)(using Context): If = tree match {
12131223
case tree: If if (cond eq tree.cond) && (thenp eq tree.thenp) && (elsep eq tree.elsep) => tree
12141224
case tree: InlineIf => finalize(tree, untpd.InlineIf(cond, thenp, elsep)(sourceFile(tree)))
@@ -1430,6 +1440,10 @@ object Trees {
14301440
cpy.Closure(tree)(transform(env), transform(meth), transform(tpt))
14311441
case Match(selector, cases) =>
14321442
cpy.Match(tree)(transform(selector), transformSub(cases))
1443+
case GadtExpr(gadt, expr) =>
1444+
inContext(ctx.withGadt(gadt))(cpy.GadtExpr(tree)(gadt, transform(expr)))
1445+
case CaseDef(pat, guard, body @ GadtExpr(gadt, _)) =>
1446+
inContext(ctx.withGadt(gadt))(cpy.CaseDef(tree)(transform(pat), transform(guard), transform(body)))
14331447
case CaseDef(pat, guard, body) =>
14341448
cpy.CaseDef(tree)(transform(pat), transform(guard), transform(body))
14351449
case Labeled(bind, expr) =>
@@ -1566,6 +1580,10 @@ object Trees {
15661580
this(this(this(x, env), meth), tpt)
15671581
case Match(selector, cases) =>
15681582
this(this(x, selector), cases)
1583+
case GadtExpr(gadt, expr) =>
1584+
inContext(ctx.withGadt(gadt))(this(x, expr))
1585+
case CaseDef(pat, guard, body @ GadtExpr(gadt, _)) =>
1586+
inContext(ctx.withGadt(gadt))(this(this(this(x, pat), guard), body))
15691587
case CaseDef(pat, guard, body) =>
15701588
this(this(this(x, pat), guard), body)
15711589
case Labeled(bind, expr) =>

‎compiler/src/dotty/tools/dotc/ast/tpd.scala

Lines changed: 9 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -92,6 +92,9 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
9292
Block(stats, expr)
9393
}
9494

95+
def GadtExpr(gadt: GadtConstraint, expr: Tree)(using Context): GadtExpr =
96+
ta.assignType(untpd.GadtExpr(gadt, expr), gadt, expr)
97+
9598
def If(cond: Tree, thenp: Tree, elsep: Tree)(using Context): If =
9699
ta.assignType(untpd.If(cond, thenp, elsep), thenp, elsep)
97100

@@ -673,6 +676,12 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
673676
}
674677
}
675678

679+
override def GadtExpr(tree: Tree)(gadt: GadtConstraint, expr: Tree)(using Context): GadtExpr =
680+
val tree1 = untpdCpy.GadtExpr(tree)(gadt, expr)
681+
tree match
682+
case tree: GadtExpr if expr.tpe eq tree.expr.tpe => tree1.withTypeUnchecked(tree.tpe)
683+
case _ => ta.assignType(tree1, gadt, expr)
684+
676685
override def If(tree: Tree)(cond: Tree, thenp: Tree, elsep: Tree)(using Context): If = {
677686
val tree1 = untpdCpy.If(tree)(cond, thenp, elsep)
678687
tree match {

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

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -382,6 +382,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
382382
def NamedArg(name: Name, arg: Tree)(implicit src: SourceFile): NamedArg = new NamedArg(name, arg)
383383
def Assign(lhs: Tree, rhs: Tree)(implicit src: SourceFile): Assign = new Assign(lhs, rhs)
384384
def Block(stats: List[Tree], expr: Tree)(implicit src: SourceFile): Block = new Block(stats, expr)
385+
def GadtExpr(gadt: GadtConstraint, expr: Tree)(implicit src: SourceFile): GadtExpr = new GadtExpr(gadt, expr)
385386
def If(cond: Tree, thenp: Tree, elsep: Tree)(implicit src: SourceFile): If = new If(cond, thenp, elsep)
386387
def InlineIf(cond: Tree, thenp: Tree, elsep: Tree)(implicit src: SourceFile): If = new InlineIf(cond, thenp, elsep)
387388
def Closure(env: List[Tree], meth: Tree, tpt: Tree)(implicit src: SourceFile): Closure = new Closure(env, meth, tpt)

‎compiler/src/dotty/tools/dotc/core/Contexts.scala

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -539,6 +539,9 @@ object Contexts {
539539
case None => fresh.dropProperty(key)
540540
}
541541

542+
final def withGadt(gadt: GadtConstraint): Context =
543+
if this.gadt eq gadt then this else fresh.setGadt(gadt)
544+
542545
def typer: Typer = this.typeAssigner match {
543546
case typer: Typer => typer
544547
case _ => new Typer

‎compiler/src/dotty/tools/dotc/core/GadtConstraint.scala

Lines changed: 37 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -31,7 +31,8 @@ sealed abstract class GadtConstraint extends Showable {
3131
*
3232
* @see [[ConstraintHandling.addToConstraint]]
3333
*/
34-
def addToConstraint(syms: List[Symbol])(using Context): Boolean
34+
def addToConstraint(syms: List[Symbol], nestingLevel: Int)(using Context): Boolean
35+
def addToConstraint(syms: List[Symbol])(using Context): Boolean = addToConstraint(syms, ctx.nestingLevel)
3536
def addToConstraint(sym: Symbol)(using Context): Boolean = addToConstraint(sym :: Nil)
3637

3738
/** Further constrain a symbol already present in the constraint. */
@@ -49,13 +50,18 @@ sealed abstract class GadtConstraint extends Showable {
4950
/** See [[ConstraintHandling.approximation]] */
5051
def approximation(sym: Symbol, fromBelow: Boolean, maxLevel: Int = Int.MaxValue)(using Context): Type
5152

53+
def remove(sym: Symbol)(using Context): Unit
54+
5255
def symbols: List[Symbol]
56+
def inputs: List[(List[Symbol], Int)]
5357

5458
def fresh: GadtConstraint
5559

5660
/** Restore the state from other [[GadtConstraint]], probably copied using [[fresh]] */
5761
def restore(other: GadtConstraint): Unit
5862

63+
def eql(that: GadtConstraint): Boolean
64+
5965
/** Provides more information than toText, by showing the underlying Constraint details. */
6066
def debugBoundsDescription(using Context): String
6167
}
@@ -89,7 +95,7 @@ final class ProperGadtConstraint private(
8995
// the case where they're valid, so no approximating is needed.
9096
rawBound
9197

92-
override def addToConstraint(params: List[Symbol])(using Context): Boolean = {
98+
override def addToConstraint(params: List[Symbol], nestingLevel: Int)(using Context): Boolean = {
9399
import NameKinds.DepParamName
94100

95101
val poly1 = PolyType(params.map { sym => DepParamName.fresh(sym.name.toTypeName) })(
@@ -127,7 +133,7 @@ final class ProperGadtConstraint private(
127133
)
128134

129135
val tvars = params.lazyZip(poly1.paramRefs).map { (sym, paramRef) =>
130-
val tv = TypeVar(paramRef, creatorState = null)
136+
val tv = TypeVar(paramRef, creatorState = null, nestingLevel)
131137
mapping = mapping.updated(sym, tv)
132138
reverseMapping = reverseMapping.updated(tv.origin, sym)
133139
tv
@@ -220,8 +226,22 @@ final class ProperGadtConstraint private(
220226
res
221227
}
222228

229+
override def remove(sym: Symbol)(using Context): Unit =
230+
mapping(sym) match
231+
case tv: TypeVar =>
232+
mapping = mapping.remove(sym)
233+
reverseMapping = reverseMapping.remove(tv.origin)
234+
constraint = constraint.replace(tv.origin, sym.typeRef)
235+
case null =>
236+
223237
override def symbols: List[Symbol] = mapping.keys
224238

239+
override def inputs: List[(List[Symbol], Int)] =
240+
constraint.domainLambdas.flatMap { tl =>
241+
val syms = tl.paramRefs.flatMap(reverseMapping(_).toOption)
242+
syms.headOption.map(sym1 => (syms, mapping(sym1).nn.initNestingLevel))
243+
}
244+
225245
override def fresh: GadtConstraint = new ProperGadtConstraint(
226246
myConstraint,
227247
mapping,
@@ -292,6 +312,14 @@ final class ProperGadtConstraint private(
292312

293313
override def constr = gadtsConstr
294314

315+
override def eql(that: GadtConstraint): Boolean = (this eq that) || that.match
316+
case that: ProperGadtConstraint =>
317+
myConstraint == that.myConstraint
318+
&& mapping == that.mapping
319+
&& reverseMapping == that.reverseMapping
320+
&& wasConstrained == that.wasConstrained
321+
case _ => false
322+
295323
override def toText(printer: Printer): Texts.Text = printer.toText(this)
296324

297325
override def debugBoundsDescription(using Context): String = i"$this\n$constraint"
@@ -307,17 +335,22 @@ final class ProperGadtConstraint private(
307335

308336
override def contains(sym: Symbol)(using Context) = false
309337

310-
override def addToConstraint(params: List[Symbol])(using Context): Boolean = unsupported("EmptyGadtConstraint.addToConstraint")
338+
override def addToConstraint(params: List[Symbol], nestingLevel: Int)(using Context): Boolean = unsupported("EmptyGadtConstraint.addToConstraint")
311339
override def addBound(sym: Symbol, bound: Type, isUpper: Boolean)(using Context): Boolean = unsupported("EmptyGadtConstraint.addBound")
312340

313341
override def approximation(sym: Symbol, fromBelow: Boolean, maxLevel: Int)(using Context): Type = unsupported("EmptyGadtConstraint.approximation")
314342

343+
override def remove(sym: Symbol)(using Context): Unit = ()
344+
315345
override def symbols: List[Symbol] = Nil
346+
override def inputs: List[(List[Symbol], Int)] = Nil
316347

317348
override def fresh = new ProperGadtConstraint
318349
override def restore(other: GadtConstraint): Unit =
319350
assert(!other.isNarrowing, "cannot restore a non-empty GADTMap")
320351

352+
override def eql(that: GadtConstraint): Boolean = (this eq that) || that == EmptyGadtConstraint
353+
321354
override def toText(printer: Printer): Texts.Text = printer.toText(this)
322355
override def debugBoundsDescription(using Context): String = i"$this"
323356
}

0 commit comments

Comments
 (0)