Merge pull request #100 from scalacenter/tasty/fix-ErasedTypeRef

translate type to ErasedTypeRef instead

Author: bishabosha

src/compiler/scala/tools/nsc/tasty/bridge/ContextOps.scala

@@ -15,7 +15,7 @@ package scala.tools.nsc.tasty.bridge
 import scala.annotation.tailrec
 import scala.reflect.io.AbstractFile
 
-import scala.tools.tasty.{TastyName, TastyFlags}, TastyFlags._
+import scala.tools.tasty.{TastyName, TastyFlags}, TastyFlags._, TastyName.ObjectName
 import scala.tools.nsc.tasty.{TastyUniverse, TastyModes, SafeEq}, TastyModes._
 import scala.reflect.internal.MissingRequirementError
 
@@ -24,7 +24,7 @@ trait ContextOps { self: TastyUniverse =>
 
   private def describeOwner(owner: Symbol): String = {
     val kind =
-      if (owner.is(Param)) {
+      if (owner.isOneOf(Param | ParamSetter)) {
         if (owner.isType) "type parameter"
         else "parameter"
       }
@@ -60,7 +60,7 @@ trait ContextOps { self: TastyUniverse =>
   @inline final def assert(assertion: Boolean): Unit =
     if (!assertion) assertError("")
 
-  sealed abstract class Context {
+  sealed abstract class Context { thisCtx =>
 
     final def globallyVisibleOwner: Symbol = owner.logicallyEnclosingMember
 
@@ -100,15 +100,9 @@ trait ContextOps { self: TastyUniverse =>
       symOrDependencyError(false, true, fullname)(loadingMirror.getPackage(encodeTermName(fullname).toString))
     }
 
-    final def requiredClass(fullname: TastyName.TypeName): Symbol =
-      symOrDependencyError(false, false, fullname)(loadingMirror.getRequiredClass(encodeTypeName(fullname).toString))
-
     final def optionalClass(fullname: TastyName.TypeName): Option[Symbol] =
       loadingMirror.getClassIfDefined(encodeTypeName(fullname).toString).toOption
 
-    final def requiredObject(fullname: TastyName.ObjectName): Symbol =
-      symOrDependencyError(true, false, fullname)(loadingMirror.getRequiredModule(encodeTermName(fullname).toString))
-
     private def symOrDependencyError(isObject: Boolean, isPackage: Boolean, fullname: TastyName)(sym: => Symbol): Symbol = {
       try sym
       catch {

src/compiler/scala/tools/nsc/tasty/bridge/SymbolOps.scala

@@ -16,6 +16,7 @@ import scala.tools.nsc.tasty.SafeEq
 
 import scala.tools.nsc.tasty.{TastyUniverse, TastyModes}, TastyModes._
 import scala.tools.tasty.{TastyName, Signature, TastyFlags}, TastyName.SignedName, Signature.MethodSignature, TastyFlags.TastyFlagSet
+import scala.tools.tasty.ErasedTypeRef
 
 trait SymbolOps { self: TastyUniverse =>
   import self.{symbolTable => u}
@@ -67,7 +68,7 @@ trait SymbolOps { self: TastyUniverse =>
       termParamss
 
   def namedMemberOfType(space: Type, tname: TastyName)(implicit ctx: Context): Symbol = tname match {
-    case SignedName(qual, sig) => signedMemberOfSpace(space, qual, sig.map(resolveErasedTypeRef))
+    case SignedName(qual, sig) => signedMemberOfSpace(space, qual, sig.map(_.encode))
     case _                     => memberOfSpace(space, tname)
   }
 
@@ -88,40 +89,57 @@ trait SymbolOps { self: TastyUniverse =>
       }
       else space.member(encodeTermName(tname))
     }
-    if (isSymbol(member)) member
-    else {
-      val kind = if (tname.isTypeName) "type" else "term"
-      def addendum(name: String) =
-        if (ctx.mode.is(ReadParents)) s"$kind in parents of ${if (ctx.owner.isLocalDummy) ctx.owner.owner else ctx.owner}: $name"
-        else if (ctx.owner.isClass) s"$kind required by a member of ${ctx.owner}: $name"
-        else s"$kind $name while unpickling ${ctx.owner}"
-      val msg =
-        if (tname.isTypeName && space.typeSymbol.hasPackageFlag)
-          s"can't find ${addendum(s"${space.typeSymbol.fullNameString}.$tname")}; perhaps it is missing from the classpath."
-        else
-          s"can't find ${addendum("" + tname)}, in $space"
-      typeError(msg)
+    if (isSymbol(member) && hasType(member)) member
+    else errorMissing(space, tname)
+  }
+
+  private def hasType(member: Symbol)(implicit ctx: Context) = {
+    ctx.mode.is(ReadAnnotation) || (member.rawInfo `ne` u.NoType)
+  }
+
+  private def errorMissing[T](space: Type, tname: TastyName)(implicit ctx: Context) = {
+    val kind = if (tname.isTypeName) "type" else "term"
+    def typeToString(tpe: Type) = {
+      def inner(sb: StringBuilder, tpe: Type): StringBuilder = tpe match {
+        case u.SingleType(pre, sym) => inner(sb, pre) append '.' append (
+          if (sym.isPackageObjectOrClass) s"`${sym.name}`"
+          else String valueOf sym.name
+        )
+        case u.TypeRef(pre, sym, _) if sym.isTerm =>
+          if ((pre eq u.NoPrefix) || (pre eq u.NoType)) sb append sym.name
+          else inner(sb, pre) append '.' append sym.name
+        case tpe => sb append tpe
+      }
+      inner(new StringBuilder(), tpe).toString
+    }
+    def addendum(name: String) = {
+      if (ctx.mode.is(ReadParents)) s"$kind in parents of ${location(if (ctx.owner.isLocalDummy) ctx.owner.owner else ctx.owner)}: $name"
+      else s"$kind required by ${location(ctx.owner)}: $name"
     }
+    val missing = addendum(s"${typeToString(space)}.$tname")
+    typeError(s"can't find $missing; perhaps it is missing from the classpath.")
   }
 
-  private def signedMemberOfSpace(space: Type, qual: TastyName, sig: MethodSignature[Type])(implicit ctx: Context): Symbol = {
-    ctx.log(s"""<<< looking for overload member[$space] @@ $qual: ${sig.show}""")
+  private def signedMemberOfSpace(space: Type, qual: TastyName, sig: MethodSignature[ErasedTypeRef])(implicit ctx: Context): Symbol = {
+    ctx.log(s"""<<< looking for overload member[$space] @@ $qual: ${showSig(sig)}""")
     val member = space.member(encodeTermName(qual))
-    val (tyParamCount, argTpes) = {
+    if (!(isSymbol(member) && hasType(member))) errorMissing(space, qual)
+    val (tyParamCount, argTpeRefs) = {
       val (tyParamCounts, params) = sig.params.partitionMap(identity)
       if (tyParamCounts.length > 1) {
-        unsupportedError(s"multiple type parameter lists on erased method signature ${sig.show}")
+        unsupportedError(s"multiple type parameter lists on erased method signature ${showSig(sig)}")
       }
       (tyParamCounts.headOption.getOrElse(0), params)
     }
     def compareSym(sym: Symbol): Boolean = sym match {
       case sym: u.MethodSymbol =>
         val params = sym.paramss.flatten
-        sym.returnType.erasure =:= sig.result &&
-        params.length === argTpes.length &&
+        val isJava = sym.isJavaDefined
+        NameErasure.sigName(sym.returnType, isJava) === sig.result &&
+        params.length === argTpeRefs.length &&
         (qual === TastyName.Constructor && tyParamCount === member.owner.typeParams.length
           || tyParamCount === sym.typeParams.length) &&
-        params.zip(argTpes).forall { case (param, tpe) => param.tpe.erasure =:= tpe } && {
+        params.zip(argTpeRefs).forall { case (param, tpe) => NameErasure.sigName(param.tpe, isJava) === tpe } && {
           ctx.log(s">>> selected ${showSym(sym)}: ${sym.tpe}")
           true
         }
@@ -130,8 +148,9 @@ trait SymbolOps { self: TastyUniverse =>
         false
     }
     member.asTerm.alternatives.find(compareSym).getOrElse(
-      typeError(s"No matching overload of $space.$qual with signature ${sig.show}"))
+      typeError(s"No matching overload of $space.$qual with signature ${showSig(sig)}"))
   }
 
+  def showSig(sig: MethodSignature[ErasedTypeRef]): String = sig.map(_.signature).show
   def showSym(sym: Symbol): String = s"Symbol($sym, #${sym.id})"
 }

src/compiler/scala/tools/nsc/tasty/bridge/TypeOps.scala

@@ -14,7 +14,7 @@ package scala.tools.nsc.tasty.bridge
 
 import scala.tools.nsc.tasty.{TastyUniverse, SafeEq}
 
-import scala.tools.tasty.{TastyName, ErasedTypeRef, TastyFlags}, TastyFlags._
+import scala.tools.tasty.{TastyName, ErasedTypeRef, TastyFlags}, TastyFlags._, TastyName.QualifiedName
 
 import scala.reflect.internal.Variance
 import scala.util.chaining._
@@ -150,15 +150,92 @@ trait TypeOps { self: TastyUniverse =>
       bounds
   }
 
-  private[bridge] def resolveErasedTypeRef(ref: ErasedTypeRef)(implicit ctx: Context): Type = {
-    import TastyName._
+  /** This is a port from Dotty of transforming a Method type to an ErasedTypeRef
+   */
+  private[bridge] object NameErasure {
+
+    def isRepeatedParam(self: Type): Boolean =
+      self.typeSymbol eq u.definitions.RepeatedParamClass
+
+    /** Translate a type of the form From[T] to either To[T] or To[? <: T] (if `wildcardArg` is set). Keep other types as they are.
+     *  `from` and `to` must be static classes, both with one type parameter, and the same variance.
+     *  Do the same for by name types => From[T] and => To[T]
+     */
+    def translateParameterized(self: Type)(from: u.ClassSymbol, to: u.ClassSymbol, wildcardArg: Boolean = false)(implicit ctx: Context): Type = self match {
+      case self @ u.NullaryMethodType(tp) =>
+        ui.nullaryMethodType(translateParameterized(tp)(from, to))
+      case _ =>
+        if (self.typeSymbol.isSubClass(from)) {
+          def elemType(tp: Type): Type = tp.dealiasWiden match {
+            // case tp: AndOrType => tp.derivedAndOrType(elemType(tp.tp1), elemType(tp.tp2))
+            case tp: u.RefinedType => ui.intersectionType(tp.parents.map(elemType))
+            case _ => tp.baseType(from).typeArgs.head
+          }
+          val arg = elemType(self)
+          val arg1 = if (wildcardArg) u.TypeBounds.upper(arg) else arg
+          to.ref(arg1 :: Nil)
+        }
+        else self
+    }
+
+    def translateFromRepeated(self: Type)(toArray: Boolean, translateWildcard: Boolean = false)(implicit ctx: Context): Type = {
+      val seqClass = if (toArray) u.definitions.ArrayClass else u.definitions.SeqClass
+      if (translateWildcard && self === u.WildcardType)
+        seqClass.ref(u.WildcardType :: Nil)
+      else if (isRepeatedParam(self))
+        // We want `Array[? <: T]` because arrays aren't covariant until after
+        // erasure. See `tests/pos/i5140`.
+        translateParameterized(self)(u.definitions.RepeatedParamClass, seqClass, wildcardArg = toArray)
+      else self
+    }
 
-    val sym = ref.qualifiedName match {
-      case TypeName(obj: ObjectName) => ctx.requiredObject(obj)
-      case clazz                     => ctx.requiredClass(clazz)
+    def sigName(tp: Type, isJava: Boolean)(implicit ctx: Context): ErasedTypeRef = {
+      val normTp = translateFromRepeated(tp)(toArray = isJava)
+      erasedSigName(normTp.erasure)
+    }
+
+    private def erasedSigName(erased: Type)(implicit ctx: Context): ErasedTypeRef = erased match {
+      case erased: u.ExistentialType => erasedSigName(erased.underlying)
+      case erased: u.TypeRef =>
+        import TastyName._
+        if (!isSymbol(erased.sym))
+          typeError(s"missing: ${erased.prefix}, ${erased.sym.name}")
+        var dims = 0
+        var clazzRef: Type = erased
+        while (clazzRef.typeArgs.nonEmpty && clazzRef.typeSymbol.isSubClass(u.definitions.ArrayClass)) {
+          dims += 1
+          clazzRef = clazzRef.typeArgs.head
+        }
+        def unpeelName(acc: List[TastyName], tpe: Type): List[TastyName] = {
+          def mkRef(sym: Symbol) = {
+            val name = SimpleName(sym.name.toString)
+            if (sym.isModuleClass && !sym.isPackageClass) ObjectName(name)
+            else name
+          }
+          def rec(pre: Type) =
+            (pre ne u.NoPrefix) && (pre ne u.NoType) && (pre.typeSymbol != u.rootMirror.RootClass)
+          tpe match {
+            case u.TypeRef(pre, sym, _) =>
+              val ref = mkRef(sym)
+              if (rec(pre)) unpeelName(ref :: acc, pre)
+              else ref :: acc
+            case tpe @ u.ThisType(sym) =>
+              val ref = mkRef(sym)
+              val pre = tpe.prefix
+              if (rec(pre)) unpeelName(ref :: acc, pre)
+              else ref :: acc
+          }
+        }
+        val name = (unpeelName(Nil, clazzRef): @unchecked) match {
+          case single :: Nil => single
+          case base :: rest  => rest.foldLeft(base)((acc, n) => n match {
+            case ObjectName(base) => ObjectName(QualifiedName(acc, PathSep, base.asSimpleName))
+            case name => QualifiedName(acc, PathSep, name.asSimpleName)
+          })
+        }
+        ErasedTypeRef(name.toTypeName, dims)
     }
 
-    (0 until ref.arrayDims).foldLeft(sym.tpe.erasure)((acc, _) => u.definitions.arrayType(acc))
   }
 
   /** A type which accepts two type arguments, representing an intersection type

src/compiler/scala/tools/tasty/ErasedTypeRef.scala

@@ -25,6 +25,7 @@ case class ErasedTypeRef(qualifiedName: TypeName, arrayDims: Int) {
     val qualified = qualifiedName.source
     "[" * arrayDims + (if (qualifiedName.toTermName.isObjectName) s"object $qualified" else qualified)
   }
+  def encode: ErasedTypeRef = ErasedTypeRef(TastyName.deepEncode(qualifiedName).toTypeName, arrayDims)
 }
 
 object ErasedTypeRef {

src/compiler/scala/tools/tasty/TastyName.scala

@@ -13,6 +13,11 @@
 package scala.tools.tasty
 
 import scala.reflect.NameTransformer
+import scala.tools.tasty.TastyName.SimpleName
+import scala.tools.tasty.TastyName.ObjectName
+import scala.tools.tasty.TastyName.SignedName
+import scala.tools.tasty.TastyName.DefaultName
+import scala.tools.tasty.TastyName.TypeName
 
 object TastyName {
 
@@ -159,6 +164,18 @@ object TastyName {
 
   }
 
+  def deepEncode(name: TastyName): TastyName = name match {
+    case SimpleName(raw) => SimpleName(NameTransformer.encode(raw))
+    case QualifiedName(qual, sep, selector) => QualifiedName(deepEncode(qual), sep, deepEncode(selector).asSimpleName)
+    case ObjectName(base) => ObjectName(deepEncode(base))
+    case UniqueName(qual, sep, num) => UniqueName(deepEncode(qual), sep, num)
+    case DefaultName(qual, num) => DefaultName(deepEncode(qual), num)
+    case PrefixName(prefix, qual) => PrefixName(prefix, deepEncode(qual))
+    case SuffixName(qual, suffix) => SuffixName(deepEncode(qual), suffix)
+    case TypeName(base) => TypeName(deepEncode(base))
+    case SignedName(qual, sig) => SignedName(deepEncode(qual), sig.map(_.encode))
+  }
+
 }
 
 /** class to represent Names as defined in TASTy, with methods to extract scala identifiers

src/reflect/scala/reflect/internal/StdNames.scala

@@ -280,6 +280,7 @@ trait StdNames {
     final val TypeName: NameType            = nameType("TypeName")
     final val TypeDef: NameType             = nameType("TypeDef")
     final val Quasiquote: NameType          = nameType("Quasiquote")
+    final val TastyMacroImpl: NameType      = nameType("TastyMacroImpl")
 
     // quasiquote-specific names
     final val QUASIQUOTE_FUNCTION: NameType     = nameType("$quasiquote$function$")

src/tastytest/scala/tools/tastytest/Dotc.scala

@@ -22,7 +22,7 @@ object Dotc {
     }
   }
 
-  def dotc(out: String, classpath: String, sources: String*): Try[Boolean] = {
+  def dotc(out: String, classpath: String, additionalSettings: Seq[String], sources: String*): Try[Boolean] = {
     if (sources.isEmpty) {
       Success(true)
     }
@@ -34,14 +34,14 @@ object Dotc {
         "-Yerased-terms",
         "-Xfatal-warnings",
         "-usejavacp"
-      ) ++ sources
+      ) ++ additionalSettings ++ sources
       dotcProcess(args)
     }
   }
 
   def main(args: Array[String]): Unit = {
     val Array(out, src) = args
-    val success = dotc(out, out, src).get
+    val success = dotc(out, out, Nil, src).get
     sys.exit(if (success) 0 else 1)
   }
 }