Map underlying -> superType in transformations

Author: odersky

compiler/src/dotty/tools/dotc/transform/ExplicitOuter.scala

@@ -317,6 +317,12 @@ object ExplicitOuter {
         case _ =>
           // Need to be careful to dealias before erasure, otherwise we lose prefixes.
           atPhaseNoLater(erasurePhase)(outerPrefix(tpe.underlying))
+          	// underlying is fine here and below since we are calling this after erasure.
+          	// However, there is some weird stuff going on with parboiled2 where an
+          	// AppliedType with a type alias as constructor is fed to outerPrefix.
+          	// For some other unknown reason this works with underlying but not with superType.
+          	// I was not able to minimize the problem and parboiled2 spits out way too much
+          	// macro generated code to be able to pinpoint the root problem.
       }
     case tpe: TypeProxy =>
       outerPrefix(tpe.underlying)

compiler/src/dotty/tools/dotc/transform/TypeUtils.scala

@@ -104,7 +104,7 @@ object TypeUtils {
       case self @ TypeRef(prefix, _) if self.symbol.isClass =>
         prefix.select(self.symbol.companionModule).asInstanceOf[TermRef]
       case self: TypeProxy =>
-        self.underlying.mirrorCompanionRef
+        self.superType.mirrorCompanionRef
     }
 
     /** Is this type a methodic type that takes implicit parameters (both old and new) at some point? */

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

@@ -286,7 +286,7 @@ trait Deriving {
             case tp @ TypeRef(prefix, _) if tp.symbol.isClass =>
               prefix.select(tp.symbol.companionModule).asInstanceOf[TermRef]
             case tp: TypeProxy =>
-              companionRef(tp.underlying)
+              companionRef(tp.superType)
           }
           val resultType = instantiated(sym.info)
           val companion = companionRef(resultType)

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

@@ -257,7 +257,7 @@ class ImplicitSearchError(
       ++ ErrorReporting.matchReductionAddendum(pt)
   }
 
-  private def formatMsg(shortForm: String)(headline: String = shortForm) = arg match 
+  private def formatMsg(shortForm: String)(headline: String = shortForm) = arg match
     case arg: Trees.SearchFailureIdent[?] =>
       arg.tpe match
         case _: NoMatchingImplicits => headline
@@ -387,7 +387,7 @@ class ImplicitSearchError(
           .map(userDefinedImplicitNotFoundTypeMessage)
           .find(_.isDefined).flatten
       case tp: TypeProxy =>
-        recur(tp.underlying)
+        recur(tp.superType)
       case tp: AndType =>
         recur(tp.tp1).orElse(recur(tp.tp2))
       case _ =>

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

@@ -549,16 +549,16 @@ object Implicits:
     override def msg(using Context) = _msg
     def explanation(using Context) = msg.toString
 
-  /** A search failure type for failed synthesis of terms for special types */ 
+  /** A search failure type for failed synthesis of terms for special types */
   class SynthesisFailure(reasons: List[String], val expectedType: Type) extends SearchFailureType:
     def argument = EmptyTree
 
-    private def formatReasons = 
-      if reasons.length > 1 then 
-        reasons.mkString("\n\t* ", "\n\t* ", "") 
-      else 
+    private def formatReasons =
+      if reasons.length > 1 then
+        reasons.mkString("\n\t* ", "\n\t* ", "")
+      else
         reasons.mkString
-      
+
     def explanation(using Context) = em"Failed to synthesize an instance of type ${clarify(expectedType)}: ${formatReasons}"
 
 end Implicits
@@ -763,7 +763,7 @@ trait ImplicitRunInfo:
               WildcardType
             else
               seen += t
-              t.underlying match
+              t.superType match
                 case TypeBounds(lo, hi) =>
                   if lo.isBottomTypeAfterErasure then apply(hi)
                   else AndType.make(apply(lo), apply(hi))
@@ -871,7 +871,7 @@ trait Implicits:
             SearchFailure(new SynthesisFailure(errors, formal), span).tree
           else
             tree.orElse(failed)
-          
+
 
   /** Search an implicit argument and report error if not found */
   def implicitArgTree(formal: Type, span: Span)(using Context): Tree = {

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

@@ -365,7 +365,7 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
                 // avoid type aliases for tuples
                 Right(MirrorSource.GenericTuple(types))
               case _ => reduce(tp.underlying)
-          case _ => reduce(tp.underlying)
+          case _ => reduce(tp.superType)
       case tp @ AndType(l, r) =>
         for
           lsrc <- reduce(l)

tests/new/test.scala

@@ -1,3 +1,23 @@
-object Test:
+abstract class TestParserSpec:
+  type TestParser1[T] = TestParser[T *: EmptyTuple, T]
+
+  def foo = 1
+
+  abstract class TestParser[L <: Tuple, Out] {
+    def baz = foo
+  }
+
+def Tests(actions: => Unit) = ()
+
+object ActionSpec extends TestParserSpec:
+  val tests = Tests {
+      val x = new TestParser1[String] {
+        //def bar = foo
+      }
+  }
+
+
+
+
+
 
-  def test = ???