Fix more problems detected by fuzzing in #4389

compiler/src/dotty/tools/dotc/ast/Trees.scala

@@ -769,28 +769,26 @@ object Trees {
   def genericEmptyTree[T >: Untyped]: Thicket[T]        = theEmptyTree.asInstanceOf[Thicket[T]]
 
   def flatten[T >: Untyped](trees: List[Tree[T]]): List[Tree[T]] = {
-    var buf: ListBuffer[Tree[T]] = null
-    var xs = trees
-    while (!xs.isEmpty) {
-      xs.head match {
-        case Thicket(elems) =>
-          if (buf == null) {
-            buf = new ListBuffer
-            var ys = trees
-            while (ys ne xs) {
-              buf += ys.head
-              ys = ys.tail
+    def recur(buf: ListBuffer[Tree[T]], remaining: List[Tree[T]]): ListBuffer[Tree[T]] =
+      remaining match {
+        case Thicket(elems) :: remaining1 =>
+          var buf1 = buf
+          if (buf1 == null) {
+            buf1 = new ListBuffer[Tree[T]]
+            var scanned = trees
+            while (scanned `ne` remaining) {
+              buf1 += scanned.head
+              scanned = scanned.tail
             }
           }
-          for (elem <- elems) {
-            assert(!elem.isInstanceOf[Thicket[_]])
-            buf += elem
-          }
-        case tree =>
+          recur(recur(buf1, elems), remaining1)
+        case tree :: remaining1 =>
           if (buf != null) buf += tree
+          recur(buf, remaining1)
+        case nil =>
+          buf
       }
-      xs = xs.tail
-    }
+    val buf = recur(null, trees)
     if (buf != null) buf.toList else trees
   }
 

compiler/src/dotty/tools/dotc/core/Constants.scala

@@ -153,7 +153,8 @@ object Constants {
      */
     def convertTo(pt: Type)(implicit ctx: Context): Constant = {
       def classBound(pt: Type): Type = pt.dealias.stripTypeVar match {
-        case tref: TypeRef if !tref.symbol.isClass => classBound(tref.info.bounds.lo)
+        case tref: TypeRef if !tref.symbol.isClass && tref.info.exists =>
+          classBound(tref.info.bounds.lo)
         case param: TypeParamRef =>
           ctx.typerState.constraint.entry(param) match {
             case TypeBounds(lo, hi) =>

compiler/src/dotty/tools/dotc/core/SymDenotations.scala

@@ -1467,8 +1467,14 @@ object SymDenotations {
         onBehalf.signalProvisional()
       val builder = new BaseDataBuilder
       for (p <- classParents) {
-        if (p.typeSymbol.isClass) builder.addAll(p.typeSymbol.asClass.baseClasses)
-        else assert(isRefinementClass || ctx.mode.is(Mode.Interactive), s"$this has non-class parent: $p")
+      	var pcls = p.typeSymbol
+      	if (!pcls.isClass) pcls = p.underlyingClassRef(refinementOK = false).typeSymbol
+      		// This roundabout way is necessary for avoiding cyclic references.
+      		// A test case is CompilationTests.compileMixed
+      	pcls match {
+          case pcls: ClassSymbol => builder.addAll(pcls.baseClasses)
+          case _ => assert(isRefinementClass || ctx.mode.is(Mode.Interactive), s"$this has non-class parent: $p")
+        }
       }
       (classSymbol :: builder.baseClasses, builder.baseClassSet)
     }

compiler/src/dotty/tools/dotc/core/TypeOps.scala

@@ -140,7 +140,7 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
         val accu1 = if (accu exists (_ derivesFrom c)) accu else c :: accu
         if (cs == c.baseClasses) accu1 else dominators(rest, accu1)
       case Nil => // this case can happen because after erasure we do not have a top class anymore
-        assert(ctx.erasedTypes)
+        assert(ctx.erasedTypes || ctx.reporter.errorsReported)
         defn.ObjectClass :: Nil
     }
 

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -589,13 +589,14 @@ object Types {
 
       def goRefined(tp: RefinedType) = {
         val pdenot = go(tp.parent)
+        val pinfo = pdenot.info
         val rinfo = tp.refinedInfo
-        if (name.isTypeName) { // simplified case that runs more efficiently
+        if (name.isTypeName && !pinfo.isInstanceOf[ClassInfo]) { // simplified case that runs more efficiently
           val jointInfo =
             if (rinfo.isAlias) rinfo
-            else if (pdenot.info.isAlias) pdenot.info
-            else if (ctx.pendingMemberSearches.contains(name)) pdenot.info safe_& rinfo
-            else pdenot.info recoverable_& rinfo
+            else if (pinfo.isAlias) pinfo
+            else if (ctx.pendingMemberSearches.contains(name)) pinfo safe_& rinfo
+            else pinfo recoverable_& rinfo
           pdenot.asSingleDenotation.derivedSingleDenotation(pdenot.symbol, jointInfo)
         } else {
           pdenot & (
@@ -3477,7 +3478,7 @@ object Types {
       if (selfTypeCache == null)
         selfTypeCache = {
           val given = cls.givenSelfType
-          if (!given.exists) appliedRef
+          if (!given.isValueType) appliedRef
           else if (cls is Module) given
           else if (ctx.erasedTypes) appliedRef
           else AndType(given, appliedRef)

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

@@ -164,8 +164,11 @@ object NamerContextOps {
   /** Find moduleClass/sourceModule in effective scope */
   private def findModuleBuddy(name: Name, scope: Scope)(implicit ctx: Context) = {
     val it = scope.lookupAll(name).filter(_ is Module)
-    assert(it.hasNext, s"no companion $name in $scope")
-    it.next()
+    if (it.hasNext) it.next()
+    else {
+      assert(ctx.reporter.errorsReported, s"no companion $name in $scope")
+      NoSymbol
+    }
   }
 }
 
@@ -1033,8 +1036,11 @@ class Namer { typer: Typer =>
    */
   def moduleValSig(sym: Symbol)(implicit ctx: Context): Type = {
     val clsName = sym.name.moduleClassName
-    val cls = ctx.denotNamed(clsName) suchThat (_ is ModuleClass)
-    ctx.owner.thisType select (clsName, cls)
+    val cls = ctx.denotNamed(clsName).suchThat(_ is ModuleClass).orElse {
+      assert(ctx.reporter.errorsReported)
+      ctx.newStubSymbol(ctx.owner, clsName)
+    }
+    ctx.owner.thisType.select(clsName, cls)
   }
 
   /** The type signature of a ValDef or DefDef

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

@@ -1447,7 +1447,11 @@ class Typer extends Namer
     assignType(cpy.TypeDef(tdef)(name, rhs1), sym)
   }
 
-  def typedClassDef(cdef: untpd.TypeDef, cls: ClassSymbol)(implicit ctx: Context) = track("typedClassDef") {
+  def typedClassDef(cdef: untpd.TypeDef, cls: ClassSymbol)(implicit ctx: Context): Tree = track("typedClassDef") {
+    if (!cls.info.isInstanceOf[ClassInfo]) {
+      assert(ctx.reporter.errorsReported)
+      return cdef.withType(UnspecifiedErrorType)
+    }
     val TypeDef(name, impl @ Template(constr, parents, self, _)) = cdef
     val superCtx = ctx.superCallContext
 

tests/neg/bad-selftype.scala

@@ -0,0 +1,6 @@
+trait x0[T] { self: x0 => }           // error
+
+trait x1[T] { self: (=> String) => }  // error
+
+trait x2[T] { self: ([X] => X) => }   // error
+

tests/neg/parser-stability-11.scala

@@ -0,0 +1,5 @@
+package x0 {
+case class x0  // error // error
+}
+package x0
+class x0  // error // error

tests/neg/parser-stability-12.scala

@@ -0,0 +1,3 @@
+trait x0[]  // error
+     trait x1[x1 <:x0]
+     extends x1[   // error

tests/neg/parser-stability-14.scala

@@ -0,0 +1,4 @@
+object x0 {
+{
+val x1 x0   // error
+object x1   // error // error

tests/neg/parser-stability-15.scala

@@ -0,0 +1,6 @@
+package x0
+class x0 {
+def x1 =
+x2 match          // error
+]                 // error
+case x3[] => x0   // error // error // error // error

tests/neg/parser-stability-16.scala

@@ -0,0 +1,5 @@
+class x0[x0] {
+  val x1 : x0
+}
+trait x3 extends x0 {
+x1 = 0 object  // error // error

tests/neg/parser-stability-17.scala

@@ -0,0 +1,2 @@
+trait x0[] {      x0: x0 => }
+        class x0[x1] extends x0[x0 x0] x2 x0

tests/neg/parser-stability-18.scala

@@ -0,0 +1,4 @@
+trait x0 {
+    class x1 (x1:x0
+    {
+type x1 <: List[x1 <:  // error // error

tests/pos/class-refinement.scala

@@ -0,0 +1,36 @@
+object Test {
+
+  class C {
+
+    class I
+
+  }
+
+  trait T
+
+  val x: C { type I <: T } = ???  // direct refinement of class member
+
+  val y: x.I = ???
+
+}
+
+class B {
+  class C {
+    type I
+  }
+  trait T
+
+  type CC <: C
+
+  val x: CC { type I <: T } = ???
+}
+
+object Test2 extends B {
+
+  class CC extends C { class I }
+
+  val y: x.I = ???        // indirect refinement of class member
+
+
+}
+