Fix two crashers

One involved selections on WildcardTypes,
the other taking the base type of refinement classes.

Both manifested themselves in neg/typeclass-encoding2.scala

Author: odersky

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

@@ -1466,7 +1466,7 @@ object SymDenotations {
       val builder = new BaseDataBuilder
       for (p <- classParents) {
         if (p.typeSymbol.isClass) builder.addAll(p.typeSymbol.asClass.baseClasses)
-        else assert(ctx.mode.is(Mode.Interactive), s"$this has non-class parent: $p")
+        else 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/Types.scala

@@ -1967,6 +1967,7 @@ object Types {
     def derivedSelect(prefix: Type)(implicit ctx: Context): Type =
       if (prefix eq this.prefix) this
       else if (prefix.isBottomType) prefix
+      else if (prefix.isInstanceOf[WildcardType]) WildcardType
       else if (isType) {
         val res =
           if (currentSymbol.is(ClassTypeParam)) argForParam(prefix)

tests/neg/typeclass-encoding2.scala

@@ -0,0 +1,26 @@
+// Used to crash with:
+//   assertion failed: class <refinement> has non-class parent
+// Once that was fixed, another crash with:
+//   assertion failed: invalid prefix WildcardType(NoType)
+object runtime1 {
+
+  trait TypeClass1[A] {
+    val common: TypeClassCommon1
+    type This[X] = common.This[X]
+  }
+
+  trait TypeClassCommon1 { self =>
+    type This[X]
+    type Instance[X] <: TypeClass1[X]
+    def inject[A](x: This[A]): Instance[A]// { val common: self.type }
+  }
+
+  trait Extension1[From[_], To[X] <: TypeClass1[X]] extends TypeClassCommon1 {
+    type This[X] = From[X]
+    type Instance[X] = To[X]
+  }
+
+  implicit def inject[A, From[_]](x: From[A])
+      (implicit ev: Extension1[From, _]): ev.Instance[A] { type This[X] = From[X] } =
+    ev.inject(x) // error: found: ev.To[A], required: ev.To[A]{This = From}
+}