Keep information about extern data types (#1296)

We were throwing away information about extern data types when
transforming to core.
This info is relevant for some Core -> Core phases (like
Monomorphization #1024), so we know whether a type is Extern instead of
guessing.

Author: mattisboeckle

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

@@ -22,6 +22,10 @@ class DeclarationContext(
     case d: Extern.Def => (d.id.name.name, d.vparams.map(_.tpe)) -> d
   }.toMap
 
+  lazy val externDatas: Map[Id, Extern.Data] = externs.collect {
+    case d: Extern.Data => d.id -> d
+  }.toMap
+
   // Maps to speed-up lookup. Assumes that, if we ever lookup a Constructor/Field/Interface/...,
   // we will eventually lookup most of them (and caches all in a respective map).
 
@@ -77,6 +81,8 @@ class DeclarationContext(
   def findExternDef(id: Id): Option[Extern.Def] = externDefs.get(id)
   def findExternDef(name: String, params: List[ValueType]): Option[Extern.Def] = externDefsName.get((name, params))
 
+  def findExternData(id: Id): Option[Extern.Data] = externDatas.get(id)
+
   def getDeclaration(id: Id)(using context: ErrorReporter): Declaration = findDeclaration(id).getOrElse {
     context.panic(s"No declaration found for ${id}.")
   }
@@ -116,6 +122,9 @@ class DeclarationContext(
   def getExternDef(id: Id)(using context: ErrorReporter): Extern.Def = findExternDef(id).getOrElse{
     context.panic(s"No extern definition found for ${id}")
   }
+  def getExternData(id: Id)(using context: ErrorReporter): Extern.Data = findExternData(id).getOrElse{
+    context.panic(s"No extern data found for ${id}")
+  }
 
   extension(field: Field) {
     def constructor(using context: ErrorReporter): Constructor = getConstructor(field)

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

@@ -82,6 +82,7 @@ class PrettyPrinter(printDetails: Boolean, printInternalIds: Boolean = true) ext
         case ExternBody.Unsupported(err) => ???
       })
     case Extern.Include(ff, contents) => "extern" <+> toDoc(ff) <+> stringLiteral(contents)
+    case Extern.Data(id, tps) => "extern type" <+> toDoc(id) <> typeParamsDoc(tps)
   }
 
   def toDoc(ff: FeatureFlag): Doc = ff match {

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

@@ -201,6 +201,11 @@ class TestRenamer(names: Names = Names(Map.empty), prefix: String = "$", preserv
     case Extern.Include(featureFlag, contents) => {
         Extern.Include(featureFlag, contents)
     }
+    case Extern.Data(id, tparams) => {
+      withBindings(tparams) {
+        Extern.Data(rewrite(id), tparams map rewrite)
+      }
+    }
   }
 
   override def rewrite(c: Constructor) = c match {
@@ -283,6 +288,7 @@ class TestRenamer(names: Names = Names(Map.empty), prefix: String = "$", preserv
       } ++ definitions.map(_.id) ++ externs.flatMap {
         case Extern.Def(id, _, _, _, _, _, _, _) => Some(id)
         case Extern.Include(_, _) => None
+        case Extern.Data(id, _) => Some(id)
       }
     }
 }

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

@@ -121,6 +121,10 @@ object Transformer extends Phase[Typechecked, CoreTransformed] {
     case d @ source.NamespaceDef(name, defs, doc, span) =>
       defs.flatMap(transformToplevel)
 
+    case e @ source.ExternType(id, _, _, _) =>
+      val sym@ExternType(name, tps, _) = e.symbol
+      List(Extern.Data(sym, tps))
+
     // For now we forget about all of the following definitions in core:
     case d: source.Def.Extern => Nil
     case d: source.Def.Alias => Nil

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

@@ -132,6 +132,7 @@ case class Property(id: Id, tpe: BlockType) extends Tree
  * FFI external definitions
  */
 enum Extern extends Tree {
+  case Data(id: Id, tparams: List[Id])
   case Def(id: Id, tparams: List[Id], cparams: List[Id], vparams: List[ValueParam], bparams: List[BlockParam], ret: ValueType, annotatedCapture: Captures, body: ExternBody)
   case Include(featureFlag: FeatureFlag, contents: String)
 }
@@ -692,6 +693,7 @@ object Tree {
         Extern.Def(rewrite(id), tparams.map(rewrite), cparams.map(rewrite), vparams.map(rewrite), bparams.map(rewrite),
           rewrite(ret), rewrite(annotatedCapture), rewrite(body).run())
       case Extern.Include(featureFlag, contents) => e
+      case Extern.Data(id, tparams) => Extern.Data(rewrite(id), tparams.map(rewrite))
     }
 
     def rewrite(d: Declaration): Declaration = d match {

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

@@ -378,6 +378,7 @@ object Type {
           wellformed(free)
 
         case Extern.Include(featureFlag, contents) => ()
+        case Extern.Data(id, tparams) => ()
       }
   }
 

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

@@ -50,6 +50,8 @@ class Deadcode(reachable: Map[Id, Usage])
           // We need to keep "show", "showBuiltin" & "infixConcat" for generating show definitions (see #1123)
           case e: Extern.Def if used(e.id) || List("show", "showBuiltin", "infixConcat").contains(e.id.name.name) => e
           case e: Extern.Include => e
+          // We currently do not have usage information on extern types, so we have to keep all of them
+          case e: Extern.Data => e
         },
         // drop unreachable definitions
         definitions.collect { case d if used(d.id) => rewrite(d) },

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

@@ -23,7 +23,7 @@ object Transformer {
   def transform(module: core.ModuleDecl): ModuleDecl = module match {
     case core.ModuleDecl(path, includes, declarations, externs, definitions, exports) =>
       given TransformationContext(Map.empty, Map.empty)
-      ModuleDecl(path, includes, declarations, externs.map(transform), definitions.map(transformToplevel), exports)
+      ModuleDecl(path, includes, declarations, externs.flatMap(transform), definitions.map(transformToplevel), exports)
   }
 
   def transformToplevel(definition: core.Toplevel)(using TransformationContext): ToplevelDefinition = definition match {
@@ -34,10 +34,11 @@ object Transformer {
       ToplevelDefinition.Val(id, ks, k, transform(stmt, ks, Continuation.Dynamic(k)))
   }
 
-  def transform(extern: core.Extern)(using TransformationContext): Extern = extern match {
+  def transform(extern: core.Extern)(using TransformationContext): Option[Extern] = extern match {
     case core.Extern.Def(id, tparams, cparams, vparams, bparams, ret, annotatedCapture, body) =>
-      Extern.Def(id, vparams.map(_.id), bparams.map(_.id), annotatedCapture.contains(symbols.builtins.AsyncCapability.capture), transform(body))
-    case core.Extern.Include(featureFlag, contents) => Extern.Include(featureFlag, contents)
+      Some(Extern.Def(id, vparams.map(_.id), bparams.map(_.id), annotatedCapture.contains(symbols.builtins.AsyncCapability.capture), transform(body)))
+    case core.Extern.Include(featureFlag, contents) => Some(Extern.Include(featureFlag, contents))
+    case core.Extern.Data(id, tparams) => None
   }
 
   def transform(externBody: core.ExternBody)(using TransformationContext): ExternBody = externBody match {

effekt/shared/src/main/scala/effekt/generator/chez/Transformer.scala

@@ -66,7 +66,7 @@ trait Transformer {
 
   def toChez(module: ModuleDecl)(using ErrorReporter): List[chez.Def] = {
     val decls = module.declarations.flatMap(toChez)
-    val externs = module.externs.map(toChez)
+    val externs = module.externs.flatMap(toChez)
      // TODO FIXME, once there is a let _ = ... in there, we are doomed!
     val defns = module.definitions.map(toChez)
     decls ++ externs ++ defns
@@ -123,20 +123,23 @@ trait Transformer {
       generateConstructor(id, operations.map(op => op.id))
   }
 
-  def toChez(decl: core.Extern)(using ErrorReporter): chez.Def = decl match {
+  def toChez(decl: core.Extern)(using ErrorReporter): Option[chez.Def] = decl match {
     case Extern.Def(id, tpe, cps, vps, bps, ret, capt, body) =>
       val tBody = body match {
         case ExternBody.StringExternBody(featureFlag, contents) => toChez(contents)
         case u: ExternBody.Unsupported =>
           u.report
           chez.Builtin("unreachable")
       }
-      chez.Constant(nameDef(id),
+      Some(chez.Constant(nameDef(id),
         chez.Lambda(vps.map { p => nameDef(p.id) } ++ bps.map { p => nameDef(p.id) },
-          tBody))
+          tBody)))
 
     case Extern.Include(ff, contents) =>
-      RawDef(contents)
+      Some(RawDef(contents))
+
+    case Extern.Data(id, tparams) =>
+      None
   }
 
   def toChez(t: Template[core.Expr]): chez.Expr =

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

@@ -31,7 +31,7 @@ object Transformer {
     given DC: DeclarationContext = core.DeclarationContext(mod.declarations, mod.externs)
 
     // collect all information
-    val declarations = mod.externs.map(transform)
+    val declarations = mod.externs.flatMap(transform)
     val definitions = mod.definitions
     val mainEntry = Label(mainName, Nil)
 
@@ -54,7 +54,7 @@ object Transformer {
     Program(declarations, toplevelDefinitions ++ localDefinitions, mainEntry)
   }
 
-  def transform(extern: core.Extern)(using BlocksParamsContext, ErrorReporter): Declaration = extern match {
+  def transform(extern: core.Extern)(using BlocksParamsContext, ErrorReporter): Option[Declaration] = extern match {
     case core.Extern.Def(name, tps, cparams, vparams, bparams, ret, capture, body) =>
       // TODO delete, and/or enforce at call site (ImpureApp)
       if bparams.nonEmpty then ErrorReporter.abort("Foreign functions currently cannot take block arguments.")
@@ -65,10 +65,13 @@ object Transformer {
       val transformedRet = transformUnboxed(ret)
       val isExternAsync = capture.contains(symbols.builtins.AsyncCapability.capture)
       noteDefinition(name, transformedParams, Nil, isExternAsync)
-      Extern(transform(name), transformedParams, transformedRet, isExternAsync, transform(body))
+      Some(Extern(transform(name), transformedParams, transformedRet, isExternAsync, transform(body)))
 
     case core.Extern.Include(ff, contents) =>
-      Include(ff, contents)
+      Some(Include(ff, contents))
+    
+    case core.Extern.Data(id, tparams) =>
+      None
   }
 
   def transform(body: core.ExternBody)(using ErrorReporter): machine.ExternBody = body match {