Merge pull request #69 from scalacenter/tasty/typeref-in

bishabosha · web-flow · commit b29bbd7e3410 · 2020-03-30T17:19:02.000+02:00
Support TERMREFin and TYPEREFin
diff --git a/src/compiler/scala/tools/nsc/tasty/TreeUnpickler.scala b/src/compiler/scala/tools/nsc/tasty/TreeUnpickler.scala
@@ -346,24 +346,16 @@ class TreeUnpickler[Tasty <: TastyUniverse](
 
         val result =
           (tag: @switch) match {
-            // case TERMREFin =>
-            //   var sname = readName()
-            //   val prefix = readType()
-            //   val space = readType()
-            //   sname match {
-            //     case SignedName(name, sig) =>
-            //       TermRef(prefix, name, space.decl(name).asSeenFrom(prefix).atSignature(sig))
-            //     case name =>
-            //       TermRef(prefix, name, space.decl(name).asSeenFrom(prefix))
-            //   }
-            // case TYPEREFin =>
-            //   val name = readName().toTypeName
-            //   val prefix = readType()
-            //   val space = readType()
-            //   space.decl(name) match {
-            //     case symd: SymDenotation if prefix.isArgPrefixOf(symd.symbol) => TypeRef(prefix, symd.symbol)
-            //     case _ => TypeRef(prefix, name, space.decl(name).asSeenFrom(prefix))
-            //   }
+            case TERMREFin =>
+              var name   = readTastyName()
+              val prefix = readType()
+              val space  = readType()
+              selectTerm(prefix, space, name)
+            case TYPEREFin =>
+              val name   = readTastyName()
+              val prefix = readType()
+              val space  = readType()
+              selectType(prefix, space, name)
             case REFINEDtype =>
               val selected = readEncodedName()
               val parent   = readType()
@@ -463,13 +455,13 @@ class TreeUnpickler[Tasty <: TastyUniverse](
           case TERMREFpkg =>
             readPackageRef().termRef
           case TYPEREF =>
-            val name = readTastyName()
-            val pre  = readType()
-            selectType(pre, name)
+            val name   = readTastyName()
+            val prefix = readType()
+            selectType(prefix, prefix, name)
           case TERMREF =>
-            val name  = readTastyName()
+            val name   = readTastyName()
             val prefix = readType()
-            selectTerm(prefix, name)
+            selectTerm(prefix, prefix, name)
           case THIS =>
             val sym = readType() match {
               case tpe: TypeRef => tpe.sym
@@ -1692,7 +1684,7 @@ class TreeUnpickler[Tasty <: TastyUniverse](
 //    def readLater[T <: AnyRef](end: Addr, op: TreeReader => Context => T)(implicit ctx: Context): Trees.Lazy[T] =
 //      readLaterWithOwner(end, op)(ctx)(ctx.owner)
 
-    def readLaterWithOwner[T <: AnyRef](end: Addr, op: TreeReader => Context => T)(implicit ctx: Context): Symbol => Trees.Lazy[T] = {
+    def readLaterWithOwner[T <: AnyRef](end: Addr, op: TreeReader => Context => T)(implicit ctx: Context): Symbol => Trees.Lazy[Option[T]] = {
       val localReader = fork
       goto(end)
       owner => new LazyReader(localReader, owner/*, ctx.mode*/, ctx.source, op)
@@ -1782,14 +1774,23 @@ class TreeUnpickler[Tasty <: TastyUniverse](
 
   class LazyReader[T <: AnyRef](
       reader: TreeReader, owner: Symbol/*, mode: Mode*/, source: AbstractFile,
-      op: TreeReader => Context => T) extends Trees.Lazy[T] {
-    def complete(implicit ctx: Context): T = {
-      ctx.log(s"starting to read at ${reader.reader.currentAddr} with owner $owner")
-      withPhaseNoLater(ctx.picklerPhase) {
-        op(reader)(ctx
-          .withOwner(owner))
-//          .withModeBits(mode)
-//          .withSource(source))
+      op: TreeReader => Context => T) extends Trees.Lazy[Option[T]] {
+    def complete(implicit ctx: Context): Option[T] = {
+      try {
+        ctx.log(s"starting to read at ${reader.reader.currentAddr} with owner $owner")
+        withPhaseNoLater(ctx.picklerPhase) {
+          Some(
+            op(reader)(ctx
+              .withOwner(owner)
+              // .withModeBits(mode)
+              // .withSource(source)
+            )
+          )
+        }
+      } catch {
+        case err: TASTyException =>
+          errorTasty(s"${err.getMessage} on ${err.sym}")
+          None
       }
     }
   }
diff --git a/src/compiler/scala/tools/nsc/tasty/bridge/AnnotationOps.scala b/src/compiler/scala/tools/nsc/tasty/bridge/AnnotationOps.scala
@@ -5,10 +5,10 @@ import scala.tools.nsc.tasty.{SafeEq, TastyUniverse}
 trait AnnotationOps extends TastyKernel { self: TastyUniverse =>
 
   object Annotation {
-    def deferredSymAndTree(annotee: Symbol)(symf: => Symbol)(tree: => Tree)(implicit ctx: Contexts.Context): Annotation =
+    def deferredSymAndTree(annotee: Symbol)(symf: => Symbol)(tree: => Option[Tree])(implicit ctx: Contexts.Context): Annotation =
       new symbolTable.LazyAnnotationInfo({
         val annotSym = symf
-        val annotTree = tree
+        val annotTree = tree.getOrElse(emptyTree)
         val isChild = defn.childAnnotationClass.exists(annotSym === _)
         ctx.log(s"annotation of $annotee = $annotTree")
         if (isChild) symbolTable.AnnotationInfo(annotTree.tpe, Nil, Nil)
diff --git a/src/compiler/scala/tools/nsc/tasty/bridge/SymbolOps.scala b/src/compiler/scala/tools/nsc/tasty/bridge/SymbolOps.scala
@@ -33,11 +33,11 @@ trait SymbolOps extends TastyKernel { self: TastyUniverse =>
     }
   }
 
-  def selectSymFromSig(qualType: Type, name: Name, sig: Signature[Type])(implicit ctx: Context): Option[(Int, Symbol)] = {
-    ctx.log(s"""looking for overload member[$qualType]("$name") @@ ${sig.show}""")
+  def selectSymFromSig(space: Type, name: Name, sig: Signature[Type])(implicit ctx: Context): Option[(Int, Symbol)] = {
+    ctx.log(s"""looking for overload member[$space]("$name") @@ ${sig.show}""")
     val MethodSignature(args, ret) = sig
     var seenTypeParams = false
-    val member = qualType.member(name)
+    val member = space.member(name)
     val (tyParamCount, argsSyms) = {
       val (tyParamCounts, params) = args.partitionMap(identity)
       if (tyParamCounts.length > 1) {
@@ -54,7 +54,7 @@ trait SymbolOps extends TastyKernel { self: TastyUniverse =>
           || tyParamCount === sym.typeParams.length) &&
         params.zip(argsSyms).forall { case (param, tpe) => param.tpe.erasure =:= tpe }
       case _ =>
-        ctx.log(s"""member[$qualType]("$name") ${showSym(sym)} is not a method""")
+        ctx.log(s"""member[$space]("$name") ${showSym(sym)} is not a method""")
         false
     }
     member.asTerm.alternatives.find(compareSym).map(tyParamCount -> _)
diff --git a/src/compiler/scala/tools/nsc/tasty/bridge/TypeOps.scala b/src/compiler/scala/tools/nsc/tasty/bridge/TypeOps.scala
@@ -124,7 +124,7 @@ trait TypeOps extends TastyKernel { self: TastyUniverse =>
    */
   case object AndType extends Type
 
-  def selectType(pre: Type, name: TastyName)(implicit ctx: Context): Type = {
+  def selectType(pre: Type, space: Type, name: TastyName)(implicit ctx: Context): Type = {
     if (pre.typeSymbol === defn.ScalaPackage && ( name === nme.And || name === nme.Or ) ) {
       if (name === nme.And) {
         AndType
@@ -135,12 +135,12 @@ trait TypeOps extends TastyKernel { self: TastyUniverse =>
       }
     }
     else {
-      selectFromPrefix(pre, name, selectingTerm = false)
+      selectFromSpaceWithPrefix(pre, space, name, selectingTerm = false)
     }
   }
 
-  def selectTerm(pre: Type, name: TastyName)(implicit ctx: Context): Type =
-    selectFromPrefix(pre, name, selectingTerm = true)
+  def selectTerm(pre: Type, space: Type, name: TastyName)(implicit ctx: Context): Type =
+    selectFromSpaceWithPrefix(pre, space, name, selectingTerm = true)
 
   /**
    * Ported from dotc
@@ -190,32 +190,41 @@ trait TypeOps extends TastyKernel { self: TastyUniverse =>
     }
   }
 
-  private def selectSymFromSig0(qualType: Type, name: Name, sig: Signature[Type])(implicit ctx: Context): Either[String,(Int, Symbol)] =
-    selectSymFromSig(qualType, name, sig).toRight(s"No matching overload of $qualType.$name with signature ${sig.show}")
+  private def selectSymFromSig0(space: Type, name: Name, sig: Signature[Type])(implicit ctx: Context): Either[String,(Int, Symbol)] =
+    selectSymFromSig(space, name, sig).toRight(s"No matching overload of $space.$name with signature ${sig.show}")
 
   private def reportThenErrorTpe(msg: String): Type = {
     reporter.error(noPosition, msg)
     errorType
   }
 
   def selectFromPrefix(pre: Type, name: TastyName, selectingTerm: Boolean)(implicit ctx: Context): Type = {
+    selectFromSpaceWithPrefix(pre, pre, name, selectingTerm)
+  }
+
+  def selectFromSpaceWithPrefix(pre: Type, space: Type, name: TastyName, selectingTerm: Boolean)(implicit ctx: Context): Type = {
     val encoded  = name.toEncodedTermName
     val selector = if (selectingTerm) encoded else encoded.toTypeName
     def debugSelectedSym(sym: Symbol): Symbol = {
       ctx.log(s"selected ${showSym(sym)} : ${sym.tpe}")
       sym
     }
+    def memberOfSpace(space: Type, name: Name): Symbol = {
+      def lookInTypeCtor = space.typeConstructor.typeParams.filter(_.name == name).headOption.getOrElse(noSymbol)
+      val fetched = space.member(name)
+      if (name.isTypeName) fetched.orElse(lookInTypeCtor) else fetched
+    }
     val resolved = name match {
       case SignedName(_, sig) =>
-        selectSymFromSig0(pre, selector, sig.map(erasedNameToErasedType)).map(pair => debugSelectedSym(pair._2))
-      case _ => Right(pre.member(selector))
+        selectSymFromSig0(space, selector, sig.map(erasedNameToErasedType)).map(pair => debugSelectedSym(pair._2))
+      case _ => Right(memberOfSpace(space, selector))
     }
     val tpeOrErr = resolved.map(sym => NamedType(pre, if (name.isModuleName) sym.linkedClassOfClass else sym))
     tpeOrErr.fold(reportThenErrorTpe, identity)
   }
 
-  def selectFromSig(qualType: Type, name: Name, sig: Signature[Type])(implicit ctx: Context): Type = {
-    val tpeOrErr = selectSymFromSig0(qualType, name, sig).map {
+  def selectFromSig(space: Type, name: Name, sig: Signature[Type])(implicit ctx: Context): Type = {
+    val tpeOrErr = selectSymFromSig0(space, name, sig).map {
       case (tyParamCount, sym) =>
         var tpe = sym.tpe
         if (name === nme.CONSTRUCTOR && tyParamCount > 0) tpe = mkPolyType(sym.owner.typeParams, tpe)
diff --git a/test/tasty/run/src-2/tastytest/TestTermRefIns.scala b/test/tasty/run/src-2/tastytest/TestTermRefIns.scala
@@ -0,0 +1,10 @@
+package tastytest
+
+object TestTermRefIns extends Suite("TestTermRefIns") {
+
+  def extractConfig(config: GenericConfig): String = config match {
+    case embedded: EmbeddedConfig => embedded.config
+  }
+
+  test(assert(extractConfig(Configurations.defaultConfig) === "config"))
+}
diff --git a/test/tasty/run/src-2/tastytest/TestTypeRefIns.scala b/test/tasty/run/src-2/tastytest/TestTypeRefIns.scala
@@ -0,0 +1,7 @@
+package tastytest
+
+object TestTypeRefIns extends Suite("TestTypeRefIns") {
+
+  test(assert(TypeRefIns.b == 1))
+
+}
diff --git a/test/tasty/run/src-3/tastytest/TermRefIns.scala b/test/tasty/run/src-3/tastytest/TermRefIns.scala
@@ -0,0 +1,18 @@
+package tastytest
+
+trait GenericConfig
+
+sealed trait EmbeddedConfig extends GenericConfig { // scala.annotation.internal.Child annotation with TERMREFin argument
+  val config: String
+}
+
+trait DefaultConfigs {
+
+  val defaultConfig: EmbeddedConfig = PrivateConfig
+
+  private case object PrivateConfig extends EmbeddedConfig {
+    val config: String = "config"
+  }
+
+}
+object Configurations extends DefaultConfigs
diff --git a/test/tasty/run/src-3/tastytest/TypeRefIns.scala b/test/tasty/run/src-3/tastytest/TypeRefIns.scala
@@ -0,0 +1,7 @@
+package tastytest
+
+object TypeRefIns {
+  type Id[A] >: A
+  val a: Array[_ >: Id[Int]] = Array(1, 2)
+  val b = a(0) // inferred TYPEREFin
+}
