Add test to simulate arena allocation of contexts in dotc

Author: odersky

tests/pos-custom-args/captures/minicheck.scala

@@ -0,0 +1,170 @@
+
+// A mini typechecker to experiment with arena allocated contexts
+import compiletime.uninitialized
+import annotation.{experimental, tailrec, constructorOnly}
+import collection.mutable
+
+case class Symbol(name: String) extends caps.Pure:
+  private var myInfo: Type = uninitialized
+  def infoOrCompleter: Type = myInfo
+  def info: Type =
+    infoOrCompleter match
+      case completer: LazyType =>
+        completer.complete()
+        info
+      case tp =>
+        tp
+  def info_=(tp: Type) = myInfo = tp
+  def exists: Boolean = true
+  def orElse(alt: => Symbol): Symbol = this
+
+object NoSymbol extends Symbol(""):
+  override def infoOrCompleter = NoType
+  override def exists: Boolean = false
+  override def orElse(alt: => Symbol): Symbol = alt
+
+abstract class Type extends caps.Pure:
+  def exists = true
+  def show: String
+class IntType()(using @constructorOnly c: Context) extends Type:
+  def show = "Int"
+class StringType()(using @constructorOnly c: Context) extends Type:
+  def show = "String"
+object NoType extends Type:
+  override def exists = false
+  def show = "<none>"
+
+abstract class LazyType(using DetachedContext) extends Type:
+  def complete(): Unit = doComplete()
+  def doComplete()(using Context): Unit
+  def show = "?"
+
+enum Tree:
+  case Let(name: String, rhs: Tree, in: Tree)
+  case Ref(name: String)
+  case Add(x: Tree, y: Tree)
+  case Length(x: Tree)
+  case Lit(value: Any)
+
+class Scope:
+  private val elems = mutable.Map[String, Symbol]()
+  def enter(sym: Symbol)(using Context): Unit =
+    if elems.contains(sym.name) then
+      report.error(s"duplicate definition: ${sym.name}")
+    elems(sym.name) = sym
+  def lookup(name: String): Symbol =
+    elems.getOrElse(name, NoSymbol)
+
+object EmptyScope extends Scope
+
+object report:
+  def error(msg: -> String)(using Context) =
+    ctx.errorCount += 1
+    println(s"ERROR: $msg")
+
+abstract class Ctx:
+  def outer: Context
+  def owner: Symbol
+  def scope: Scope
+  var errorCount: Int = 0
+  def detached: DetachedContext
+
+type Context = {*} Ctx
+
+abstract class DetachedContext extends Ctx:
+  def outer: DetachedContext
+
+class FreshCtx(val level: Int) extends DetachedContext:
+  var outer: FreshCtx = uninitialized
+  var owner: Symbol = uninitialized
+  var scope: Scope = uninitialized
+  def initFrom(other: Context): this.type =
+    outer = other.asInstanceOf[FreshCtx]
+    owner = other.owner
+    scope = other.scope
+    this
+  def detached: DetachedContext =
+    var c = this
+    while c.level >= 0 && (ctxStack(c.level) eq c) do
+      ctxStack(c.level) = null
+      c = c.outer
+    this
+
+object NoContext extends FreshCtx(-1):
+  owner = NoSymbol
+  scope = EmptyScope
+
+type FreshContext = {*} FreshCtx
+
+def ctx(using c: Context): {c} Ctx = c
+
+var ctxStack: Array[FreshContext] = new Array(10)
+var curLevel = 0
+
+def inFreshContext[T](op: FreshContext ?-> T)(using Context): T =
+  if curLevel == ctxStack.length then
+    val prev = ctxStack
+    ctxStack = new Array[FreshContext](curLevel * 2)
+    Array.copy(prev, 0, ctxStack, 0, prev.length)
+  if ctxStack(curLevel) == null then
+    ctxStack(curLevel) = FreshCtx(curLevel)
+  val result = ctxStack(curLevel).initFrom(ctx)
+  curLevel += 1
+  try op(using result)
+  finally curLevel -= 1
+
+def withOwner[T](owner: Symbol)(op: Context ?-> T)(using Context): T =
+  val prev = ctx
+  inFreshContext { c ?=>
+    c.owner = owner
+    op
+  }
+
+def withScope[T](scope: Scope)(op: Context ?-> T)(using Context): T =
+  val prev = ctx
+  inFreshContext { c ?=>
+    c.scope = scope
+    op
+  }
+
+def typed(tree: Tree, expected: Type = NoType)(using Context): Type =
+  val tp = typedUnadapted(tree, expected)
+  if expected.exists && tp != expected then
+    report.error(
+      s"""Type error
+         |found   : $tp
+         |expected: $expected
+         |for     : $tree""".stripMargin)
+  tp
+
+import Tree.*
+def typedUnadapted(tree: Tree, expected: Type = NoType)(using ctx: Context): Type = tree match
+  case Let(name, rhs, in) =>
+    val sym = Symbol(name)
+    val dctx = ctx.detached
+    sym.info = new LazyType(using dctx):
+      override def doComplete()(using Context) =
+        sym.info = withOwner(sym)(withScope(new Scope())(typed(rhs)))
+    ctx.scope.enter(sym)
+    try typed(in, expected)
+    finally sym.info
+  case Ref(name: String) =>
+    def findIn(c: Context): Symbol =
+      val sym = c.scope.lookup(name)
+      if sym.exists || (c eq NoContext) then sym
+      else findIn(c.outer)
+    findIn(ctx).info
+  case Add(x: Tree, y: Tree) =>
+    typed(x, IntType())
+    typed(y, IntType())
+    IntType()
+  case Length(x: Tree) =>
+    typed(x, StringType())
+    IntType()
+  case Lit(value: Any) =>
+    value match
+      case value: Int => IntType()
+      case value: String => StringType()
+      case _ =>
+        report.error(s"Int or String literzal expected by $value found")
+        NoType