Add small local test project

Author: bracevac

local/project/dummy/arrows.scala

@@ -0,0 +1,35 @@
+package dummy
+
+import language.experimental.captureChecking
+import caps.*
+
+trait Arrows:
+  val a: AnyRef^
+  val b: AnyRef^
+  val c: AnyRef^
+
+  val purev: Int -> Int
+  val purev2: Int ->{} Int
+  val impurev: Int => Int
+  val impurev2: Int ->{a,b,c} Int
+  val impurev3: Int ->{a,b,c} Int => Int
+
+  def pure(f: Int -> Int): Int
+  def pure2(f: Int ->{} Int): Int
+  def impure(f: Int => Int): Int
+  def impure2(f: Int ->{a,b,c} Int): Int
+  def impure3(f: Int ->{a,b,c} Int => Int): Int
+
+  def uses(@use a: AnyRef^): Any
+  def uses2(@use x: AnyRef^{a}, @use y: AnyRef^{b}): Any
+
+  def consumes(@consume a: AnyRef^): Any
+  def consumes2(@consume x: AnyRef^{a}, @consume y: AnyRef^{b}): Any
+
+  def usesAndConsumes(@use a: AnyRef^, @consume b: AnyRef^): Any
+  def usesAndConsumes2(@use @consume x: AnyRef^{a}): Any
+  def consumesAndUses(@consume @use x: AnyRef^{a}): Any
+
+  def byNamePure(f: -> Int): Int
+  def byNameImpure(f: ->{a,b,c} Int): Int
+  def byNameImpure2(f: => Int): Int

local/project/dummy/capturevars.scala

@@ -0,0 +1,16 @@
+package dummy
+
+import language.experimental.captureChecking
+
+trait Test:
+    type T[-C^]
+    type U[+C^]
+    type C^
+    type D^
+    def foo[C^](x: T[C]): Unit
+    def bar(x: T[{}]): Unit
+    def baz(x: T[{caps.cap}]): Unit
+    def foo2[C^](x: U[C]): Unit
+    def bar2(x: U[{}]): Unit
+    def baz2(x: U[{caps.cap}]): Unit
+    def test[E^, F^ >: {caps.cap} <: {}](x: T[E], y: U[F]): Unit

local/project/dummy/colltest.scala

@@ -0,0 +1,34 @@
+package dummy
+
+import language.experimental.captureChecking
+// Showing a problem with recursive references
+object CollectionStrawMan5 {
+
+  /** Base trait for generic collections */
+  trait Iterable[+A] extends IterableLike[A] {
+    def iterator: Iterator[A]^{this}
+    def coll: Iterable[A]^{this} = this
+  }
+
+  trait IterableLike[+A]:
+    def coll: Iterable[A]^{this}
+    def partition(p: A => Boolean): Unit =
+      val pn = Partition(coll, p)
+      ()
+
+  /** Concrete collection type: View */
+  trait View[+A] extends Iterable[A] with IterableLike[A]
+
+  case class Partition[A](val underlying: Iterable[A]^, p: A => Boolean) {
+
+    class Partitioned(expected: Boolean) extends View[A]:
+      this: Partitioned^{Partition.this} =>
+      def iterator: Iterator[A]^{this} =
+        underlying.iterator.filter((x: A) => p(x) == expected)
+
+    val left: Partitioned^{Partition.this} = Partitioned(true)
+    val right: Partitioned^{Partition.this} = Partitioned(false)
+  }
+
+
+}

mystuff.sbt

@@ -0,0 +1,43 @@
+import sbt._
+import sbt.io.IO
+
+import sbt.dsl.LinterLevel.Ignore
+
+lazy val compileSrcTree = taskKey[Unit]("Example project")
+
+compileSrcTree := {
+  val log         = streams.value.log
+  val baseDir     = baseDirectory.value
+  val srcTreeDir  = baseDir / "local" / "project"
+  val outDir      = baseDir / "local" / "out"
+
+  IO.delete(outDir)
+  IO.createDirectory(outDir)                              // mkdir -p
+
+  val sources: Seq[String] =
+    (srcTreeDir ** "*.scala").get.map(_.getPath)          // find  all .scala
+
+  if (sources.isEmpty)
+    streams.value.log.warn(s"No .scala files found under $srcTreeDir")
+  else {
+    val cmd = ("scalac" +: "-d" +: outDir.getPath +: sources).mkString(" ")
+    Command.process(cmd, state.value)
+  }
+}
+
+lazy val ensureApiDir = taskKey[Unit]("Create <repo>/local/api if it’s missing")
+
+ensureApiDir := {
+  val dir = (ThisBuild / baseDirectory).value / "local" / "api"
+  IO.createDirectory(dir)
+}
+
+addCommandAlias(
+  "myrefresh",
+  ";compileSrcTree; ensureApiDir ; scaladoc/runMain dotty.tools.scaladoc.Main -siteroot /dev/null -project Foo -project-version 0.0.1 -d local/api local/out"
+)
+
+addCommandAlias(
+  "myscaladoc",
+  "; ensureApiDir ; scaladoc/runMain dotty.tools.scaladoc.Main -siteroot /dev/null -project Foo -project-version 0.0.1 -d local/api local/out"
+)

scaladoc/src/dotty/tools/scaladoc/cc/CaptureOps.scala

@@ -47,8 +47,9 @@ def decomposeCaptureRefs(using qctx: Quotes)(typ0: qctx.reflect.TypeRepr): Optio
       case t @ ThisType(_)    => buffer += t; true
       case t @ TermRef(_, _)  => buffer += t; true
       case t @ ParamRef(_, _) => buffer += t; true
+      case t if t.typeSymbol == defn.NothingClass => true
        // TODO: are atoms only ever the above? Then we could refine the return type
-      case _ => report.warning(s"Unexpected type tree $typ while trying to extract capture references from $typ0"); System.exit(1); false // TODO remove warning eventually
+      case _ => report.warning(s"Unexpected type tree $typ while trying to extract capture references from $typ0"); false // TODO remove warning eventually
   if traverse(typ0) then Some(buffer.toList) else None
 end decomposeCaptureRefs
 

scaladoc/src/dotty/tools/scaladoc/tasty/TypesSupport.scala

@@ -109,8 +109,8 @@ trait TypesSupport:
           case List(ref) if ref.isCaptureRoot =>
             keyword("=> ") :: inner(tpe)
           case refs =>
-            keyword("->") :: (renderCaptureSet(refs) ++ inner(tpe))
-      case ByNameType(tpe) => keyword("=> ") :: inner(tpe) // FIXME: does it need change for CC?
+            keyword("->") :: (renderCaptureSet(refs) ++ (plain(" ") :: inner(tpe)))
+      case ByNameType(tpe) => keyword("=>!! ") :: inner(tpe) // FIXME: does it need change for CC?
       case ConstantType(constant) =>
         plain(constant.show).l
       case ThisType(tpe) =>