makes internal.decorators signatures work

After fighting with path-dependent types to express wrappee.type,
I decided to take a different approach and replaced wrappee.type with
parametric polymorphism.

3 files changed, 37 insertions, 34 deletions

diff --git a/src/reflect/scala/reflect/api/Internals.scala b/src/reflect/scala/reflect/api/Internals.scala
index c2e56e954a..913177040c 100644
--- a/src/reflect/scala/reflect/api/Internals.scala
+++ b/src/reflect/scala/reflect/api/Internals.scala
@@ -3,6 +3,7 @@ package reflect
 package api
 
 import scala.language.implicitConversions
+import scala.language.higherKinds
 
 /**
  *  <span class="badge badge-red" style="float: right;">EXPERIMENTAL</span>
@@ -363,13 +364,13 @@ trait Internals { self: Universe =>
     /** @see [[Decorators]] */
     trait DecoratorApi {
       /** Extension methods for trees */
-      type TreeDecorator <: TreeDecoratorApi
+      type TreeDecorator[T <: Tree] <: TreeDecoratorApi[T]
 
       /** @see [[TreeDecorator]] */
-      implicit def treeDecorator(tree: Tree): TreeDecorator
+      implicit def treeDecorator[T <: Tree](tree: T): TreeDecorator[T]
 
       /** @see [[TreeDecorator]] */
-      class TreeDecoratorApi(val tree: Tree) {
+      class TreeDecoratorApi[T <: Tree](val tree: T) {
         /** @see [[internal.freeTerms]] */
         def freeTerms: List[FreeTermSymbol] = internal.freeTerms(tree)
 
@@ -387,13 +388,13 @@ trait Internals { self: Universe =>
       }
 
       /** Extension methods for symbols */
-      type SymbolDecorator <: SymbolDecoratorApi
+      type SymbolDecorator[T <: Symbol] <: SymbolDecoratorApi[T]
 
       /** @see [[SymbolDecorator]] */
-      implicit def symbolDecorator(symbol: Symbol): SymbolDecorator
+      implicit def symbolDecorator[T <: Symbol](symbol: T): SymbolDecorator[T]
 
       /** @see [[SymbolDecorator]] */
-      class SymbolDecoratorApi(val symbol: Symbol) {
+      class SymbolDecoratorApi[T <: Symbol](val symbol: T) {
         /** @see [[internal.isFreeTerm]] */
         def isFreeTerm: Boolean = internal.isFreeTerm(symbol)
 
@@ -431,22 +432,22 @@ trait Internals { self: Universe =>
         def deSkolemize: Symbol = internal.deSkolemize(symbol)
 
         /** @see [[internal.initialize]] */
-        def initialize: symbol.type = internal.initialize(symbol)
+        def initialize: T = internal.initialize(symbol)
 
         /** @see [[internal.fullyInitialize]] */
-        def fullyInitialize: symbol.type = internal.fullyInitialize(symbol)
+        def fullyInitialize: T = internal.fullyInitialize(symbol)
       }
 
       /** Extension methods for types */
-      type TypeDecorator <: TypeDecoratorApi
+      type TypeDecorator[T <: Type] <: TypeDecoratorApi[T]
 
       /** @see [[TypeDecorator]] */
-      implicit def typeDecorator(tp: Type): TypeDecorator
+      implicit def typeDecorator[T <: Type](tp: T): TypeDecorator[T]
 
       /** @see [[TypeDecorator]] */
-      implicit class TypeDecoratorApi(val tp: Type) {
+      implicit class TypeDecoratorApi[T <: Type](val tp: T) {
         /** @see [[internal.fullyInitialize]] */
-        def fullyInitialize: tp.type = internal.fullyInitialize(tp)
+        def fullyInitialize: T = internal.fullyInitialize(tp)
       }
     }
   }
diff --git a/src/reflect/scala/reflect/internal/Internals.scala b/src/reflect/scala/reflect/internal/Internals.scala
index 6308a97dbc..4bb05b0af1 100644
--- a/src/reflect/scala/reflect/internal/Internals.scala
+++ b/src/reflect/scala/reflect/internal/Internals.scala
@@ -3,6 +3,7 @@ package reflect
 package internal
 
 import scala.language.implicitConversions
+import scala.language.higherKinds
 import scala.collection.mutable.WeakHashMap
 import scala.ref.WeakReference
 import scala.reflect.api.Universe
@@ -125,12 +126,12 @@ trait Internals extends api.Internals {
 
     type Decorators = MacroDecoratorApi
     lazy val decorators: Decorators = new MacroDecoratorApi {
-      override type TreeDecorator = MacroTreeDecoratorApi
-      override implicit def treeDecorator(tree: Tree): TreeDecorator = new MacroTreeDecoratorApi(tree)
-      override type SymbolDecorator = MacroSymbolDecoratorApi
-      override implicit def symbolDecorator(symbol: Symbol): SymbolDecorator = new MacroSymbolDecoratorApi(symbol)
-      override type TypeDecorator = TypeDecoratorApi
-      override implicit def typeDecorator(tp: Type): TypeDecorator = new TypeDecoratorApi(tp)
+      override type TreeDecorator[T <: Tree] = MacroTreeDecoratorApi[T]
+      override implicit def treeDecorator[T <: Tree](tree: T): TreeDecorator[T] = new MacroTreeDecoratorApi[T](tree)
+      override type SymbolDecorator[T <: Symbol] = MacroSymbolDecoratorApi[T]
+      override implicit def symbolDecorator[T <: Symbol](symbol: T): SymbolDecorator[T] = new MacroSymbolDecoratorApi[T](symbol)
+      override type TypeDecorator[T <: Type] = TypeDecoratorApi[T]
+      override implicit def typeDecorator[T <: Type](tp: T): TypeDecorator[T] = new TypeDecoratorApi[T](tp)
     }
   }
 
diff --git a/src/reflect/scala/reflect/macros/Universe.scala b/src/reflect/scala/reflect/macros/Universe.scala
index 11281551f1..3906a3388d 100644
--- a/src/reflect/scala/reflect/macros/Universe.scala
+++ b/src/reflect/scala/reflect/macros/Universe.scala
@@ -3,6 +3,7 @@ package reflect
 package macros
 
 import scala.language.implicitConversions
+import scala.language.higherKinds
 
 /**
  * <span class="badge badge-red" style="float: right;">EXPERIMENTAL</span>
@@ -143,10 +144,10 @@ abstract class Universe extends scala.reflect.api.Universe {
     /** @inheritdoc */
     trait MacroDecoratorApi extends DecoratorApi {
       /** @inheritdoc */
-      type TreeDecorator <: MacroTreeDecoratorApi
+      override type TreeDecorator[T <: Tree] <: MacroTreeDecoratorApi[T]
 
       /** @see [[TreeDecorator]] */
-      class MacroTreeDecoratorApi(override val tree: Tree) extends TreeDecoratorApi(tree) {
+      class MacroTreeDecoratorApi[T <: Tree](override val tree: T) extends TreeDecoratorApi[T](tree) {
         /** @see [[internal.changeOwner]] */
         def changeOwner(prev: Symbol, next: Symbol): tree.type = internal.changeOwner(tree, prev, next)
 
@@ -154,49 +155,49 @@ abstract class Universe extends scala.reflect.api.Universe {
         def attachments: Attachments { type Pos = Position } = internal.attachments(tree)
 
         /** @see [[internal.updateAttachment]] */
-        def updateAttachment[T: ClassTag](attachment: T): tree.type = internal.updateAttachment(tree, attachment)
+        def updateAttachment[A: ClassTag](attachment: A): tree.type = internal.updateAttachment(tree, attachment)
 
         /** @see [[internal.removeAttachment]] */
-        def removeAttachment[T: ClassTag]: tree.type = internal.removeAttachment[T](tree)
+        def removeAttachment[A: ClassTag]: T = internal.removeAttachment[A](tree)
 
         /** @see [[internal.setPos]] */
-        def setPos(newpos: Position): tree.type = internal.setPos(tree, newpos)
+        def setPos(newpos: Position): T = internal.setPos(tree, newpos)
 
         /** @see [[internal.setType]] */
-        def setType(tp: Type): tree.type = internal.setType(tree, tp)
+        def setType(tp: Type): T = internal.setType(tree, tp)
 
         /** @see [[internal.defineType]] */
-        def defineType(tp: Type): tree.type = internal.defineType(tree, tp)
+        def defineType(tp: Type): T = internal.defineType(tree, tp)
 
         /** @see [[internal.setSymbol]] */
-        def setSymbol(sym: Symbol): tree.type = internal.setSymbol(tree, sym)
+        def setSymbol(sym: Symbol): T = internal.setSymbol(tree, sym)
       }
 
       /** @inheritdoc */
-      type SymbolDecorator <: MacroSymbolDecoratorApi
+      override type SymbolDecorator[T <: Symbol] <: MacroSymbolDecoratorApi[T]
 
       /** @see [[TreeDecorator]] */
-      class MacroSymbolDecoratorApi(override val symbol: Symbol) extends SymbolDecoratorApi(symbol) {
+      class MacroSymbolDecoratorApi[T <: Symbol](override val symbol: T) extends SymbolDecoratorApi[T](symbol) {
         /** @see [[internal.attachments]] */
         def attachments: Attachments { type Pos = Position } = internal.attachments(symbol)
 
         /** @see [[internal.updateAttachment]] */
-        def updateAttachment[T: ClassTag](attachment: T): symbol.type = internal.updateAttachment(symbol, attachment)
+        def updateAttachment[A: ClassTag](attachment: A): T = internal.updateAttachment(symbol, attachment)
 
         /** @see [[internal.removeAttachment]] */
-        def removeAttachment[T: ClassTag]: symbol.type = internal.removeAttachment[T](symbol)
+        def removeAttachment[A: ClassTag]: T = internal.removeAttachment[A](symbol)
 
         /** @see [[internal.setInfo]] */
-        def setInfo(tpe: Type): symbol.type = internal.setInfo(symbol, tpe)
+        def setInfo(tpe: Type): T = internal.setInfo(symbol, tpe)
 
         /** @see [[internal.setAnnotations]] */
-        def setAnnotations(annots: Annotation*): symbol.type = internal.setAnnotations(symbol, annots: _*)
+        def setAnnotations(annots: Annotation*): T = internal.setAnnotations(symbol, annots: _*)
 
         /** @see [[internal.setName]] */
-        def setName(name: Name): symbol.type = internal.setName(symbol, name)
+        def setName(name: Name): T = internal.setName(symbol, name)
 
         /** @see [[internal.setPrivateWithin]] */
-        def setPrivateWithin(sym: Symbol): symbol.type = internal.setPrivateWithin(symbol, sym)
+        def setPrivateWithin(sym: Symbol): T = internal.setPrivateWithin(symbol, sym)
       }
     }
   }