Fix typing of RefinedTypes with watching parents

If a refined type has a parent type watching some other type, the parent
should not be mapped to Object. Previously, the parent counted as `isEmpty`
which caused this mapping.

Also: Complete and cleanup hylolib tests

Author: odersky

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -2206,7 +2206,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
   }
 
   def typedRefinedTypeTree(tree: untpd.RefinedTypeTree)(using Context): TypTree = {
-    val tpt1 = if (tree.tpt.isEmpty) TypeTree(defn.ObjectType) else typedAheadType(tree.tpt)
+    val tpt1 = if tree.tpt == EmptyTree then TypeTree(defn.ObjectType) else typedAheadType(tree.tpt)
     val refineClsDef = desugar.refinedTypeToClass(tpt1, tree.refinements).withSpan(tree.span)
     val refineCls = createSymbol(refineClsDef).asClass
     val TypeDef(_, impl: Template) = typed(refineClsDef): @unchecked

compiler/test/dotc/pos-test-pickling.blacklist

@@ -119,3 +119,6 @@ parsercombinators-givens.scala
 parsercombinators-ctx-bounds.scala
 parsercombinators-this.scala
 parsercombinators-arrow.scala
+parsercombinators-new-syntax.scala
+hylolib
+

tests/pos/hylolib/AnyCollection.scala

@@ -1,3 +1,4 @@
+//> using options -language:experimental.modularity -source future
 package hylo
 
 /** A type-erased collection.
@@ -14,12 +15,7 @@ final class AnyCollection[Element] private (
 object AnyCollection {
 
   /** Creates an instance forwarding its operations to `base`. */
-  def apply[Base: Collection as b](base: Base): AnyCollection[b.Element] =
-    // NOTE: This evidence is redefined so the compiler won't report ambiguity between `intIsValue`
-    // and `anyValueIsValue` when the method is called on a collection of `Int`s. None of these
-    // choices is even correct! Note also that the ambiguity is suppressed if the constructor of
-    // `AnyValue` is declared with a context bound rather than an implicit parameter.
-    given b.Position is Value = b.Position
+  def apply[Base: Collection](base: Base): AnyCollection[Base.Element] =
 
     def start(): AnyValue =
       AnyValue(base.startPosition)
@@ -28,12 +24,12 @@ object AnyCollection {
       AnyValue(base.endPosition)
 
     def after(p: AnyValue): AnyValue =
-      AnyValue(base.positionAfter(p.unsafelyUnwrappedAs[b.Position]))
+      AnyValue(base.positionAfter(p.unsafelyUnwrappedAs[Base.Position]))
 
-    def at(p: AnyValue): b.Element =
-      base.at(p.unsafelyUnwrappedAs[b.Position])
+    def at(p: AnyValue): Base.Element =
+      base.at(p.unsafelyUnwrappedAs[Base.Position])
 
-    new AnyCollection[b.Element](
+    new AnyCollection[Base.Element](
       _start = start,
       _end = end,
       _after = after,

tests/pos/hylolib/AnyValueTests.scala

@@ -0,0 +1,15 @@
+//> using options -language:experimental.modularity -source future
+import hylo.*
+import hylo.given
+
+class AnyValueTests extends munit.FunSuite:
+
+  test("eq"):
+    val a = AnyValue(1)
+    assert(a `eq` a)
+    assert(!(a `neq` a))
+
+    val b = AnyValue(2)
+    assert(!(a `eq` b))
+    assert(a `neq` b)
+

tests/pos/hylolib/CollectionTests.scala

@@ -0,0 +1,67 @@
+//> using options -language:experimental.modularity -source future
+import hylo.*
+import hylo.given
+
+class CollectionTests extends munit.FunSuite:
+
+  test("isEmpty"):
+    val empty = AnyCollection(HyArray[Int]())
+    assert(empty.isEmpty)
+
+    val nonEmpty = AnyCollection(HyArray[Int](1, 2))
+    assert(!nonEmpty.isEmpty)
+
+  test("count"):
+    val a = AnyCollection(HyArray[Int](1, 2))
+    assertEquals(a.count, 2)
+
+  test("isBefore"):
+    val empty = AnyCollection(HyArray[Int]())
+    assert(!empty.isBefore(empty.startPosition, empty.endPosition))
+
+    val nonEmpty = AnyCollection(HyArray[Int](1, 2))
+    val p0 = nonEmpty.startPosition
+    val p1 = nonEmpty.positionAfter(p0)
+    val p2 = nonEmpty.positionAfter(p1)
+    assert(nonEmpty.isBefore(p0, nonEmpty.endPosition))
+    assert(nonEmpty.isBefore(p1, nonEmpty.endPosition))
+    assert(!nonEmpty.isBefore(p2, nonEmpty.endPosition))
+
+  test("headAndTail"):
+    val empty = AnyCollection(HyArray[Int]())
+    assertEquals(empty.headAndTail, None)
+
+    val one = AnyCollection(HyArray[Int](1))
+    val Some((h0, t0)) = one.headAndTail: @unchecked
+    assert(h0 eq 1)
+    assert(t0.isEmpty)
+
+    val two = AnyCollection(HyArray[Int](1, 2))
+    val Some((h1, t1)) = two.headAndTail: @unchecked
+    assertEquals(h1, 1)
+    assertEquals(t1.count, 1)
+
+  test("reduce"):
+    val empty = AnyCollection(HyArray[Int]())
+    assertEquals(empty.reduce(0)((s, x) => s + x), 0)
+
+    val nonEmpty = AnyCollection(HyArray[Int](1, 2, 3))
+    assertEquals(nonEmpty.reduce(0)((s, x) => s + x), 6)
+
+  test("forEach"):
+    val empty = AnyCollection(HyArray[Int]())
+    assert(empty.forEach((e) => false))
+
+    val nonEmpty = AnyCollection(HyArray[Int](1, 2, 3))
+    var s = 0
+    assert(nonEmpty.forEach((e) => { s += e; true }))
+    assertEquals(s, 6)
+
+    s = 0
+    assert(!nonEmpty.forEach((e) => { s += e; false }))
+    assertEquals(s, 1)
+
+  test("elementsEqual"):
+    val a = HyArray(1, 2)
+    assert(a.elementsEqual(a))
+end CollectionTests

tests/pos/hylolib/Hasher.scala

@@ -1,3 +1,4 @@
+//> using options -language:experimental.modularity -source future
 package hylo
 
 import scala.util.Random

tests/pos/hylolib/HyArray.scala

@@ -56,7 +56,6 @@ final class HyArray[Element: Value as elementIsCValue](
     result._count += 1
     result
 
-  // NOTE: Can't refine `C.Element` without renaming the generic parameter of `HyArray`.
   /** Adds the contents of `source` at the end of the array. */
   def appendContents[C: Collection { type Element = HyArray.this.Element }](
       source: C, assumeUniqueness: Boolean = false

tests/pos/hylolib/HyArrayTests.scala

@@ -0,0 +1,17 @@
+import hylo.*
+import hylo.given
+
+class HyArrayTests extends munit.FunSuite:
+
+  test("reserveCapacity"):
+    var a = HyArray[Int]()
+    a = a.append(1)
+    a = a.append(2)
+
+    a = a.reserveCapacity(10)
+    assert(a.capacity >= 10)
+    assertEquals(a.count, 2)
+    assertEquals(a.at(0), 1)
+    assertEquals(a.at(1), 2)
+
+end HyArrayTests

tests/pos/hylolib/IntegersTests.scala

@@ -0,0 +1,14 @@
+//> using options -language:experimental.modularity -source future
+import hylo.*
+import hylo.given
+
+class IntegersTests extends munit.FunSuite:
+
+    test("Int.hashInto"):
+        val x = Hasher.hash(42)
+        val y = Hasher.hash(42)
+        assertEquals(x, y)
+
+        val z = Hasher.hash(1337)
+        assertNotEquals(x, z)
+

tests/pos/hylolib/Test.scala

@@ -0,0 +1,16 @@
+//> using options -language:experimental.modularity -source future
+import hylo.*
+import hylo.given
+
+object munit:
+    open class FunSuite:
+        def test(name: String)(op: => Unit): Unit = op
+        def assertEquals[T](x: T, y: T) = assert(x == y)
+        def assertNotEquals[T](x: T, y: T) = assert(x != y)
+
+@main def Test =
+    CollectionTests()
+    AnyValueTests()
+    HyArrayTests()
+    IntegersTests()
+    println("done")

tests/pos/i13580.scala

@@ -0,0 +1,13 @@
+//> using options -language:experimental.modularity -source future
+trait IntWidth:
+  type Out
+given IntWidth:
+  type Out = 155
+
+trait IntCandidate:
+  type Out
+given (using tracked val w: IntWidth) => IntCandidate:
+  type Out = w.Out
+
+val x = summon[IntCandidate]
+val xx = summon[x.Out =:= 155]

tests/pos/parsercombinators-new-syntax.scala

@@ -0,0 +1,45 @@
+//> using options -language:experimental.modularity -source future
+import collection.mutable
+
+/// A parser combinator.
+trait Combinator:
+
+  type Self
+  type Input
+  type Result
+
+  extension (self: Self)
+    /// Parses and returns an element from input `in`.
+    def parse(in: Input): Option[Result]
+end Combinator
+
+case class Apply[C, E](action: C => Option[E])
+case class Combine[A, B](first: A, second: B)
+
+given [I, R] => Apply[I, R] is Combinator:
+  type Input = I
+  type Result = R
+  extension (self: Self)
+    def parse(in: I): Option[R] = self.action(in)
+
+given [A: Combinator, B: Combinator { type Input = A.Input }]
+    => Combine[A, B] is Combinator:
+  type Input = A.Input
+  type Result = (A.Result, B.Result)
+  extension (self: Self)
+    def parse(in: Input): Option[Result] = ???
+
+extension [A] (buf: mutable.ListBuffer[A]) def popFirst() =
+  if buf.isEmpty then None
+  else try Some(buf.head) finally buf.remove(0)
+
+@main def hello: Unit =
+  val source = (0 to 10).toList
+  val stream = source.to(mutable.ListBuffer)
+
+  val n = Apply[mutable.ListBuffer[Int], Int](s => s.popFirst())
+  val m = Combine(n, n)
+
+  val r = m.parse(stream) // was error: type mismatch, found `mutable.ListBuffer[Int]`, required `?1.Input`
+  val rc: Option[(Int, Int)] = r
+