Properly represent existentials in core (effekt-lang#880)

Co-authored-by: Jonathan Brachthäuser <[email protected]>

Author: 2 people

effekt/jvm/src/test/scala/effekt/core/PatternMatchingTests.scala

@@ -38,10 +38,10 @@ class PatternMatchingTests extends CoreTests {
         List(
           Condition.Patterns(Map(x -> Pattern.Any(y.id))),
           Condition.Patterns(Map(y -> Pattern.Any(z.id)))),
-        f, List(z)))
+        f, Nil, List(z)))
 
     // case => f(z)
-    val expected = Clause(Nil, f, List(x))
+    val expected = Clause(Nil, f, Nil, List(x))
 
     assertEquals(normalized, expected)
   }
@@ -73,11 +73,11 @@ class PatternMatchingTests extends CoreTests {
           Condition.Patterns(Map(sc -> Pattern.Any(x.id))),
           Condition.Val(p.id, TBoolean, trivalPredicate),
           Condition.Predicate(p)),
-        b1, List(x)),
+        b1, Nil, List(x)),
       Clause(
         List(
           Condition.Patterns(Map(sc -> Pattern.Ignore()))),
-        b2, List())))
+        b2, Nil, List())))
 
     val expected =
       Val(p.id, TBoolean, trivalPredicate,
@@ -124,14 +124,14 @@ class PatternMatchingTests extends CoreTests {
     val result = compile(List(
       Clause(
         List(
-          Condition.Patterns(Map(opt -> Pattern.Tag(SomeC, List(Pattern.Any(v.id) -> TInt)))),
+          Condition.Patterns(Map(opt -> Pattern.Tag(SomeC, List(), List(Pattern.Any(v.id) -> TInt)))),
           Condition.Val(p.id, TBoolean, trivalPredicate),
           Condition.Predicate(p)),
-        b1, List(v)),
+        b1, Nil, List(v)),
       Clause(
         List(
           Condition.Patterns(Map(opt -> Pattern.Ignore()))),
-        b2, List())))
+        b2, Nil, List())))
 
     // opt match {
     //   case Some(tmp) => val p = return v > 0; if (p) { b1(tmp) } else { b2() }

effekt/shared/src/main/scala/effekt/core/Parser.scala

@@ -168,7 +168,7 @@ class CoreParsers(positions: Positions, names: Names) extends EffektLexers(posit
     ( literal
     | id ~ (`:` ~> valueType) ^^ Pure.ValueVar.apply
     | `box` ~> captures ~ block ^^ { case capt ~ block => Pure.Box(block, capt) }
-    | `make` ~> dataType ~ id ~ valueArgs ^^ Pure.Make.apply
+    | `make` ~> dataType ~ id ~ maybeTypeArgs ~ valueArgs ^^ Pure.Make.apply
     | maybeParens(blockVar) ~ maybeTypeArgs ~ valueArgs ^^ Pure.PureApp.apply
     | failure("Expected a pure expression.")
     )

effekt/shared/src/main/scala/effekt/core/PatternMatchingCompiler.scala

@@ -1,9 +1,7 @@
 package effekt
 package core
 
-import effekt.context.Context
 import effekt.core.substitutions.Substitution
-import effekt.symbols.TmpValue
 
 import scala.collection.mutable
 
@@ -54,9 +52,9 @@ import scala.collection.mutable
 object PatternMatchingCompiler {
 
   /**
-   * The conditions need to be met in sequence before the block at [[label]] can be evaluated with given [[args]].
+   * The conditions need to be met in sequence before the block at [[label]] can be evaluated with given [[targs]] and [[args]].
    */
-  case class Clause(conditions: List[Condition], label: BlockVar, args: List[ValueVar])
+  case class Clause(conditions: List[Condition], label: BlockVar, targs: List[ValueType], args: List[ValueVar])
 
   enum Condition {
     // all of the patterns need to match for this condition to be met
@@ -71,7 +69,7 @@ object PatternMatchingCompiler {
   enum Pattern {
     // sub-patterns are annotated with the inferred type of the scrutinee at this point
     // i.e. Cons(Some(x : TInt): Option[Int], xs: List[Option[Int]])
-    case Tag(id: Id, patterns: List[(Pattern, ValueType)])
+    case Tag(id: Id, tparams: List[Id], patterns: List[(Pattern, ValueType)])
     case Ignore()
     case Any(id: Id)
     case Or(patterns: List[Pattern])
@@ -93,21 +91,21 @@ object PatternMatchingCompiler {
     // (1) Check the first clause to be matched (we can immediately handle non-pattern cases)
     val patterns = headClause match {
       // - The top-most clause already matches successfully
-      case Clause(Nil, target, args) =>
-        return core.App(target, Nil, args, Nil)
+      case Clause(Nil, target, targs, args) =>
+        return core.App(target, targs, args, Nil)
       // - We need to perform a computation
-      case Clause(Condition.Val(x, tpe, binding) :: rest, target, args) =>
-        return core.Val(x, tpe, binding, compile(Clause(rest, target, args) :: remainingClauses))
+      case Clause(Condition.Val(x, tpe, binding) :: rest, target, targs, args) =>
+        return core.Val(x, tpe, binding, compile(Clause(rest, target, targs, args) :: remainingClauses))
       // - We need to perform a computation
-      case Clause(Condition.Let(x, tpe, binding) :: rest, target, args) =>
-        return core.Let(x, tpe, binding, compile(Clause(rest, target, args) :: remainingClauses))
+      case Clause(Condition.Let(x, tpe, binding) :: rest, target, targs, args) =>
+        return core.Let(x, tpe, binding, compile(Clause(rest, target, targs, args) :: remainingClauses))
       // - We need to check a predicate
-      case Clause(Condition.Predicate(pred) :: rest, target, args) =>
+      case Clause(Condition.Predicate(pred) :: rest, target, targs, args) =>
         return core.If(pred,
-          compile(Clause(rest, target, args) :: remainingClauses),
+          compile(Clause(rest, target, targs, args) :: remainingClauses),
           compile(remainingClauses)
         )
-      case Clause(Condition.Patterns(patterns) :: rest, target, args) =>
+      case Clause(Condition.Patterns(patterns) :: rest, target, targs, args) =>
         patterns
     }
 
@@ -127,7 +125,7 @@ object PatternMatchingCompiler {
     def splitOnLiteral(lit: Literal, equals: (Pure, Pure) => Pure): core.Stmt = {
       // the different literal values that we match on
       val variants: List[core.Literal] = normalized.collect {
-        case Clause(Split(Pattern.Literal(lit, _), _, _), _, _) => lit
+        case Clause(Split(Pattern.Literal(lit, _), _, _), _, _, _) => lit
       }.distinct
 
       // for each literal, we collect the clauses that match it correctly
@@ -141,8 +139,8 @@ object PatternMatchingCompiler {
         defaults = defaults :+ cl
 
       normalized.foreach {
-        case Clause(Split(Pattern.Literal(lit, _), restPatterns, restConds), label, args) =>
-          addClause(lit, Clause(Condition.Patterns(restPatterns) :: restConds, label, args))
+        case Clause(Split(Pattern.Literal(lit, _), restPatterns, restConds), label, targs, args) =>
+          addClause(lit, Clause(Condition.Patterns(restPatterns) :: restConds, label, targs, args))
         case c =>
           addDefault(c)
           variants.foreach { v => addClause(v, c) }
@@ -164,7 +162,7 @@ object PatternMatchingCompiler {
     def splitOnTag() = {
       // collect all variants that are mentioned in the clauses
       val variants: List[Id] = normalized.collect {
-        case Clause(Split(p: Pattern.Tag, _, _), _, _) => p.id
+        case Clause(Split(p: Pattern.Tag, _, _), _, _, _) => p.id
       }.distinct
 
       // for each tag, we collect the clauses that match it correctly
@@ -179,7 +177,9 @@ object PatternMatchingCompiler {
 
       // used to make up new scrutinees
       val varsFor = mutable.Map.empty[Id, List[ValueVar]]
-      def fieldVarsFor(constructor: Id, fieldInfo: List[((Pattern, ValueType), String)]): List[ValueVar] =
+      val tvarsFor = mutable.Map.empty[Id, List[Id]]
+      def fieldVarsFor(constructor: Id, tparams: List[Id], fieldInfo: List[((Pattern, ValueType), String)]): List[ValueVar] =
+        tvarsFor.getOrElseUpdate(constructor, tparams)
         varsFor.getOrElseUpdate(
           constructor,
           fieldInfo.map {
@@ -191,17 +191,17 @@ object PatternMatchingCompiler {
         )
 
       normalized.foreach {
-        case Clause(Split(Pattern.Tag(constructor, patternsAndTypes), restPatterns, restConds), label, args) =>
+        case Clause(Split(Pattern.Tag(constructor, tparams, patternsAndTypes), restPatterns, restConds), label, targs, args) =>
           // NOTE: Ideally, we would use a `DeclarationContext` here, but we cannot: we're currently in the Source->Core transformer, so we do not have all of the details yet.
           val fieldNames: List[String] = constructor match {
             case c: symbols.Constructor => c.fields.map(_.name.name)
             case _ => List.fill(patternsAndTypes.size) { "y" } // NOTE: Only reached in PatternMatchingTests
           }
-          val fieldVars = fieldVarsFor(constructor, patternsAndTypes.zip(fieldNames))
+          val fieldVars = fieldVarsFor(constructor, tparams, patternsAndTypes.zip(fieldNames))
           val nestedMatches = fieldVars.zip(patternsAndTypes.map { case (pat, tpe) => pat }).toMap
           addClause(constructor,
             // it is important to add nested matches first, since they might include substitutions for the rest.
-            Clause(Condition.Patterns(nestedMatches) :: Condition.Patterns(restPatterns) :: restConds, label, args))
+            Clause(Condition.Patterns(nestedMatches) :: Condition.Patterns(restPatterns) :: restConds, label, targs, args))
 
         case c =>
           // Clauses that don't match on that var are duplicated.
@@ -214,8 +214,9 @@ object PatternMatchingCompiler {
       // (4) assemble syntax tree for the pattern match
       val branches = variants.map { v =>
         val body = compile(clausesFor.getOrElse(v, Nil))
+        val tparams = tvarsFor(v)
         val params = varsFor(v).map { case ValueVar(id, tpe) => core.ValueParam(id, tpe): core.ValueParam }
-        val blockLit: BlockLit = BlockLit(Nil, Nil, params, Nil, body)
+        val blockLit: BlockLit = BlockLit(tparams, Nil, params, Nil, body)
         (v, blockLit)
       }
 
@@ -232,16 +233,17 @@ object PatternMatchingCompiler {
 
   def branchingHeuristic(patterns: Map[ValueVar, Pattern], clauses: List[Clause]): ValueVar =
     patterns.keys.maxBy(v => clauses.count {
-      case Clause(ps, _, _) => ps.contains(v)
+      case Clause(ps, _, _, _) => ps.contains(v)
     })
 
   /**
    * Substitutes AnyPattern and removes wildcards.
    */
   def normalize(clause: Clause): Clause = clause match {
-    case Clause(conditions, label, args) =>
+    case Clause(conditions, label, targs, args) =>
       val (normalized, substitution) = normalize(Map.empty, conditions, Map.empty)
-      Clause(normalized, label, args.map(v => substitution.getOrElse(v.id, v)))
+      // TODO also substitute types?
+      Clause(normalized, label, targs, args.map(v => substitution.getOrElse(v.id, v)))
   }
 
 
@@ -309,8 +311,8 @@ object PatternMatchingCompiler {
   // -----------------------------
 
   def show(cl: Clause): String = cl match {
-    case Clause(conditions, label, args) =>
-      s"case ${conditions.map(show).mkString("; ")} => ${util.show(label.id)}${args.map(x => util.show(x)).mkString("(", ", ", ")")}"
+    case Clause(conditions, label, targs, args) =>
+      s"case ${conditions.map(show).mkString("; ")} => ${util.show(label.id)}${targs.map(x => util.show(x))}${args.map(x => util.show(x)).mkString("(", ", ", ")")}"
   }
 
   def show(c: Condition): String = c match {
@@ -321,7 +323,7 @@ object PatternMatchingCompiler {
   }
 
   def show(p: Pattern): String = p match {
-    case Pattern.Tag(id, patterns) => util.show(id) + patterns.map { case (p, tpe) => show(p) }.mkString("(", ", ", ")")
+    case Pattern.Tag(id, tparams, patterns) => util.show(id) + tparams.map(util.show).mkString("[", ",", "]") + patterns.map { case (p, tpe) => show(p) }.mkString("(", ", ", ")")
     case Pattern.Ignore() => "_"
     case Pattern.Any(id) => util.show(id)
     case Pattern.Or(patterns) => patterns.map(show).mkString(" | ")

effekt/shared/src/main/scala/effekt/core/PolymorphismBoxing.scala

@@ -349,15 +349,15 @@ object PolymorphismBoxing extends Phase[CoreTransformed, CoreTransformed] {
       val vCoerced = (vargs zip tpe.vparams).map { (a, tpe) => coerce(transform(a), tpe) }
       coerce(PureApp(callee, targs.map(transformArg), vCoerced), itpe.result)
 
-    case Pure.Make(data, tag, vargs) =>
+    case Pure.Make(data, tag, targs, vargs) =>
       val dataDecl = PContext.getData(data.name)
       val ctorDecl = dataDecl.constructors.find(_.id == tag).getOrElse {
         Context.panic(pp"No constructor found for tag ${tag} in data type: ${data}")
       }
       val paramTypes = ctorDecl.fields.map(_.tpe)
 
       val coercedArgs = (vargs zip paramTypes).map { case (arg, paramTpe) => coerce(transform(arg), paramTpe) }
-      Pure.Make(transform(data), tag, coercedArgs)
+      Pure.Make(transform(data), tag, targs.map(transformArg), coercedArgs)
 
     case Pure.Box(b, annotatedCapture) =>
       Pure.Box(transform(b), annotatedCapture)

effekt/shared/src/main/scala/effekt/core/PrettyPrinter.scala

@@ -100,7 +100,7 @@ object PrettyPrinter extends ParenPrettyPrinter {
     case ValueVar(id, _)           => toDoc(id)
 
     case PureApp(b, targs, vargs)  => toDoc(b) <> argsToDoc(targs, vargs, Nil)
-    case Make(data, tag, vargs)    => "make" <+> toDoc(data) <+> toDoc(tag) <> argsToDoc(Nil, vargs, Nil)
+    case Make(data, tag, targs, vargs)    => "make" <+> toDoc(data) <+> toDoc(tag) <> argsToDoc(targs, vargs, Nil)
     case DirectApp(b, targs, vargs, bargs) => toDoc(b) <> argsToDoc(targs, vargs, bargs)
 
     case Box(b, capt) => parens("box" <+> toDoc(b))

effekt/shared/src/main/scala/effekt/core/Recursive.scala

@@ -94,7 +94,7 @@ class Recursive(
     case Pure.ValueVar(id, annotatedType) => ()
     case Pure.Literal(value, annotatedType) => ()
     case Pure.PureApp(b, targs, vargs) => process(b); vargs.foreach(process)
-    case Pure.Make(data, tag, vargs) => vargs.foreach(process)
+    case Pure.Make(data, tag, targs, vargs) => vargs.foreach(process)
     case Pure.Box(b, annotatedCapture) => process(b)
   }
 

effekt/shared/src/main/scala/effekt/core/Transformer.scala

@@ -273,13 +273,13 @@ object Transformer extends Phase[Typechecked, CoreTransformed] {
               Stmt.Return(PureApp(BlockVar(b), targs, vargs)))
           }
 
-          // [[ f ]] = { (x) => make f(x) }
+          // [[ f ]] = { [A](x) => make f[A](x) }
           def etaExpandConstructor(b: Constructor): BlockLit = {
             assert(bparamtps.isEmpty)
             assert(effects.isEmpty)
             assert(cparams.isEmpty)
             BlockLit(tparams, Nil, vparams, Nil,
-              Stmt.Return(Make(core.ValueType.Data(b.tpe, targs), b, vargs)))
+              Stmt.Return(Make(core.ValueType.Data(b.tpe, targs), b, targs, vargs)))
           }
 
           // [[ f ]] = { (x){g} => let r = f(x){g}; return r }
@@ -668,6 +668,15 @@ object Transformer extends Phase[Typechecked, CoreTransformed] {
       case MatchGuard.BooleanGuard(condition) => Nil
       case MatchGuard.PatternGuard(scrutinee, pattern) => boundInPattern(pattern)
     }
+    def boundTypesInPattern(p: source.MatchPattern): List[Id] = p match {
+      case source.AnyPattern(id) => List()
+      case p @ source.TagPattern(id, patterns) => Context.annotation(Annotations.TypeParameters, p) ++ patterns.flatMap(boundTypesInPattern)
+      case _: source.LiteralPattern | _: source.IgnorePattern => Nil
+    }
+    def boundTypesInGuard(g: source.MatchGuard): List[Id] = g match {
+      case MatchGuard.BooleanGuard(condition) => Nil
+      case MatchGuard.PatternGuard(scrutinee, pattern) => boundTypesInPattern(pattern)
+    }
     def equalsFor(tpe: symbols.ValueType): (Pure, Pure) => Pure =
       val prelude = Context.module.findDependency(QualifiedName(Nil, "effekt")).getOrElse {
         Context.panic(pp"${Context.module.name.name}: Cannot find 'effekt' in prelude, which is necessary to compile pattern matching.")
@@ -685,14 +694,16 @@ object Transformer extends Phase[Typechecked, CoreTransformed] {
       } getOrElse { Context.panic(pp"Cannot find == for type ${tpe} in prelude!") }
 
     // create joinpoint
+    val tparams = patterns.flatMap { case (sc, p) => boundTypesInPattern(p) } ++ guards.flatMap(boundTypesInGuard)
     val params = patterns.flatMap { case (sc, p) => boundInPattern(p) } ++ guards.flatMap(boundInGuard)
-    val joinpoint = Context.bind(TmpBlock(label), BlockLit(Nil, Nil, params, Nil, body))
+    val joinpoint = Context.bind(TmpBlock(label), BlockLit(tparams, Nil, params, Nil, body))
 
     def transformPattern(p: source.MatchPattern): Pattern = p match {
       case source.AnyPattern(id) =>
         Pattern.Any(id.symbol)
-      case source.TagPattern(id, patterns) =>
-        Pattern.Tag(id.symbol, patterns.map { p => (transformPattern(p), transform(Context.inferredTypeOf(p))) })
+      case p @ source.TagPattern(id, patterns) =>
+        val tparams = Context.annotation(Annotations.TypeParameters, p)
+        Pattern.Tag(id.symbol, tparams, patterns.map { p => (transformPattern(p), transform(Context.inferredTypeOf(p))) })
       case source.IgnorePattern() =>
         Pattern.Ignore()
       case source.LiteralPattern(source.Literal(value, tpe)) =>
@@ -719,7 +730,7 @@ object Transformer extends Phase[Typechecked, CoreTransformed] {
     val transformedGuards   = guards.flatMap(transformGuard)
     val conditions = if transformedPatterns.isEmpty then transformedGuards else Condition.Patterns(transformedPatterns) :: guards.flatMap(transformGuard)
 
-    Clause(conditions, joinpoint, params.map(p => core.ValueVar(p.id, p.tpe)))
+    Clause(conditions, joinpoint, tparams.map(x => core.ValueType.Var(x)), params.map(p => core.ValueVar(p.id, p.tpe)))
   }
 
   /**
@@ -785,7 +796,9 @@ object Transformer extends Phase[Typechecked, CoreTransformed] {
         DirectApp(BlockVar(f), targs, vargsT, bargsT)
       case r: Constructor =>
         if (bargs.nonEmpty) Context.abort("Constructors cannot take block arguments.")
-        Make(core.ValueType.Data(r.tpe, targs), r, vargsT)
+        val universals = targs.take(r.tpe.tparams.length)
+        val existentials = targs.drop(r.tpe.tparams.length)
+        Make(core.ValueType.Data(r.tpe, universals), r, existentials, vargsT)
       case f: Operation =>
         Context.panic("Should have been translated to a method call!")
       case f: Field =>

effekt/shared/src/main/scala/effekt/core/Tree.scala

@@ -191,7 +191,7 @@ enum Pure extends Expr {
    *
    * Note: the structure mirrors interface implementation
    */
-  case Make(data: ValueType.Data, tag: Id, vargs: List[Pure])
+  case Make(data: ValueType.Data, tag: Id, targs: List[ValueType], vargs: List[Pure])
 
   case Box(b: Block, annotatedCapture: Captures)
 }
@@ -578,7 +578,7 @@ object Variables {
     case Pure.ValueVar(id, annotatedType) => Variables.value(id, annotatedType)
     case Pure.Literal(value, annotatedType) => Variables.empty
     case Pure.PureApp(b, targs, vargs) => free(b) ++ all(vargs, free)
-    case Pure.Make(data, tag, vargs) => all(vargs, free)
+    case Pure.Make(data, tag, targs, vargs) => all(vargs, free)
     case Pure.Box(b, annotatedCapture) => free(b)
   }
 
@@ -772,8 +772,8 @@ object substitutions {
       case Literal(value, annotatedType) =>
         Literal(value, substitute(annotatedType))
 
-      case Make(tpe, tag, vargs) =>
-        Make(substitute(tpe).asInstanceOf, tag, vargs.map(substitute))
+      case Make(tpe, tag, targs, vargs) =>
+        Make(substitute(tpe).asInstanceOf, tag, targs.map(substitute), vargs.map(substitute))
 
       case PureApp(f, targs, vargs) => substitute(f) match {
         case g : Block.BlockVar => PureApp(g, targs.map(substitute), vargs.map(substitute))

effekt/shared/src/main/scala/effekt/core/Type.scala

@@ -252,7 +252,7 @@ object Type {
     case Pure.ValueVar(id, tpe) => tpe
     case Pure.Literal(value, tpe) => tpe
     case Pure.PureApp(callee, targs, args) => instantiate(callee.functionType, targs, Nil).result
-    case Pure.Make(tpe, tag, args) => tpe
+    case Pure.Make(tpe, tag, targs, args) => tpe // TODO instantiate?
     case Pure.Box(block, capt) => ValueType.Boxed(block.tpe, capt)
   }
 

effekt/shared/src/main/scala/effekt/core/optimizer/BindSubexpressions.scala

@@ -126,8 +126,8 @@ object BindSubexpressions {
     case Pure.ValueVar(id, tpe) => pure(ValueVar(transform(id), transform(tpe)))
     case Pure.Literal(value, tpe) => pure(Pure.Literal(value, transform(tpe)))
 
-    case Pure.Make(data, tag, vargs) => transformExprs(vargs) { vs =>
-      bind(Pure.Make(data, tag, vs))
+    case Pure.Make(data, tag, targs, vargs) => transformExprs(vargs) { vs =>
+      bind(Pure.Make(data, tag, targs, vs))
     }
     case DirectApp(f, targs, vargs, bargs) => for {
       vs <- transformExprs(vargs);