provides extension methods for internal

Based on my scala/async migration experiences, I can say that having
to write `setType(tree, tpe)` instead of `tree.setType(tpe)` is a major
pain. That's why I think it makes sense to expose some functions in internal
as extension methods.

3 files changed, 171 insertions, 2 deletions

diff --git a/src/reflect/scala/reflect/api/Internals.scala b/src/reflect/scala/reflect/api/Internals.scala
index 014750b023..c2e56e954a 100644
--- a/src/reflect/scala/reflect/api/Internals.scala
+++ b/src/reflect/scala/reflect/api/Internals.scala
@@ -51,7 +51,7 @@ trait Internals { self: Universe =>
    *
    *  @group Internal
    */
-  trait InternalApi {
+  trait InternalApi { internal =>
     /** This is an internal implementation module.
      */
     val reificationSupport: ReificationSupportApi
@@ -353,6 +353,102 @@ trait Internals { self: Universe =>
     /** A creator for `BoundedWildcardType` types.
      */
     def boundedWildcardType(bounds: TypeBounds): BoundedWildcardType
+
+    /** Syntactic conveniences for additional internal APIs for trees, symbols and types */
+    type Decorators <: DecoratorApi
+
+    /** @see [[Decorators]] */
+    val decorators: Decorators
+
+    /** @see [[Decorators]] */
+    trait DecoratorApi {
+      /** Extension methods for trees */
+      type TreeDecorator <: TreeDecoratorApi
+
+      /** @see [[TreeDecorator]] */
+      implicit def treeDecorator(tree: Tree): TreeDecorator
+
+      /** @see [[TreeDecorator]] */
+      class TreeDecoratorApi(val tree: Tree) {
+        /** @see [[internal.freeTerms]] */
+        def freeTerms: List[FreeTermSymbol] = internal.freeTerms(tree)
+
+        /** @see [[internal.freeTypes]] */
+        def freeTypes: List[FreeTypeSymbol] = internal.freeTypes(tree)
+
+        /** @see [[internal.substituteSymbols]] */
+        def substituteSymbols(from: List[Symbol], to: List[Symbol]): Tree = internal.substituteSymbols(tree, from, to)
+
+        /** @see [[internal.substituteTypes]] */
+        def substituteTypes(from: List[Symbol], to: List[Type]): Tree = internal.substituteTypes(tree, from, to)
+
+        /** @see [[internal.substituteThis]] */
+        def substituteThis(clazz: Symbol, to: Tree): Tree = internal.substituteThis(tree, clazz, to)
+      }
+
+      /** Extension methods for symbols */
+      type SymbolDecorator <: SymbolDecoratorApi
+
+      /** @see [[SymbolDecorator]] */
+      implicit def symbolDecorator(symbol: Symbol): SymbolDecorator
+
+      /** @see [[SymbolDecorator]] */
+      class SymbolDecoratorApi(val symbol: Symbol) {
+        /** @see [[internal.isFreeTerm]] */
+        def isFreeTerm: Boolean = internal.isFreeTerm(symbol)
+
+        /** @see [[internal.asFreeTerm]] */
+        def asFreeTerm: FreeTermSymbol = internal.asFreeTerm(symbol)
+
+        /** @see [[internal.isFreeType]] */
+        def isFreeType: Boolean = internal.isFreeType(symbol)
+
+        /** @see [[internal.asFreeType]] */
+        def asFreeType: FreeTypeSymbol = internal.asFreeType(symbol)
+
+        /** @see [[internal.newTermSymbol]] */
+        def newTermSymbol(name: TermName, pos: Position = NoPosition, flags: FlagSet = NoFlags): TermSymbol = internal.newTermSymbol(symbol, name, pos, flags)
+
+        /** @see [[internal.newModuleAndClassSymbol]] */
+        def newModuleAndClassSymbol(name: Name, pos: Position = NoPosition, flags: FlagSet = NoFlags): (ModuleSymbol, ClassSymbol) = internal.newModuleAndClassSymbol(symbol, name, pos, flags)
+
+        /** @see [[internal.newMethodSymbol]] */
+        def newMethodSymbol(name: TermName, pos: Position = NoPosition, flags: FlagSet = NoFlags): MethodSymbol = internal.newMethodSymbol(symbol, name, pos, flags)
+
+        /** @see [[internal.newTypeSymbol]] */
+        def newTypeSymbol(name: TypeName, pos: Position = NoPosition, flags: FlagSet = NoFlags): TypeSymbol = internal.newTypeSymbol(symbol, name, pos, flags)
+
+        /** @see [[internal.newClassSymbol]] */
+        def newClassSymbol(name: TypeName, pos: Position = NoPosition, flags: FlagSet = NoFlags): ClassSymbol = internal.newClassSymbol(symbol, name, pos, flags)
+
+        /** @see [[internal.isErroneous]] */
+        def isErroneous: Boolean = internal.isErroneous(symbol)
+
+        /** @see [[internal.isSkolem]] */
+        def isSkolem: Boolean = internal.isSkolem(symbol)
+
+        /** @see [[internal.deSkolemize]] */
+        def deSkolemize: Symbol = internal.deSkolemize(symbol)
+
+        /** @see [[internal.initialize]] */
+        def initialize: symbol.type = internal.initialize(symbol)
+
+        /** @see [[internal.fullyInitialize]] */
+        def fullyInitialize: symbol.type = internal.fullyInitialize(symbol)
+      }
+
+      /** Extension methods for types */
+      type TypeDecorator <: TypeDecoratorApi
+
+      /** @see [[TypeDecorator]] */
+      implicit def typeDecorator(tp: Type): TypeDecorator
+
+      /** @see [[TypeDecorator]] */
+      implicit class TypeDecoratorApi(val tp: Type) {
+        /** @see [[internal.fullyInitialize]] */
+        def fullyInitialize: tp.type = internal.fullyInitialize(tp)
+      }
+    }
   }
 
   /** This is an internal implementation class.
diff --git a/src/reflect/scala/reflect/internal/Internals.scala b/src/reflect/scala/reflect/internal/Internals.scala
index 5e718ce4bd..974578240e 100644
--- a/src/reflect/scala/reflect/internal/Internals.scala
+++ b/src/reflect/scala/reflect/internal/Internals.scala
@@ -122,6 +122,16 @@ trait Internals extends api.Internals {
     def boundedWildcardType(bounds: TypeBounds): BoundedWildcardType = self.BoundedWildcardType(bounds)
 
     def subpatterns(tree: Tree): Option[List[Tree]] = tree.attachments.get[SubpatternsAttachment].map(_.patterns.map(_.duplicate))
+
+    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)
+    }
   }
 
   lazy val treeBuild = new self.TreeGen {
diff --git a/src/reflect/scala/reflect/macros/Universe.scala b/src/reflect/scala/reflect/macros/Universe.scala
index 8521b782e3..3319965844 100644
--- a/src/reflect/scala/reflect/macros/Universe.scala
+++ b/src/reflect/scala/reflect/macros/Universe.scala
@@ -23,7 +23,7 @@ abstract class Universe extends scala.reflect.api.Universe {
   override type Internal <: MacroInternalApi
 
   /** @inheritdoc */
-  trait MacroInternalApi extends InternalApi {
+  trait MacroInternalApi extends InternalApi { internal =>
 
     /** Collects all the symbols defined by subtrees of `tree` that are owned by `prev`,
      *  and then changes their owner to point to `next`.
@@ -136,6 +136,69 @@ abstract class Universe extends scala.reflect.api.Universe {
      *  Useful in writing quasiquoting macros that do pattern matching.
      */
     def subpatterns(tree: Tree): Option[List[Tree]]
+
+    /** @inheritdoc */
+    override type Decorators <: MacroDecoratorApi
+
+    /** @inheritdoc */
+    trait MacroDecoratorApi extends DecoratorApi {
+      /** @inheritdoc */
+      type TreeDecorator <: MacroTreeDecoratorApi
+
+      /** @see [[TreeDecorator]] */
+      class MacroTreeDecoratorApi(override val tree: Tree) extends TreeDecoratorApi(tree) {
+        /** @see [[internal.changeOwner]] */
+        def changeOwner(prev: Symbol, next: Symbol): tree.type = internal.changeOwner(tree, prev, next)
+
+        /** @see [[internal.attachments]] */
+        def attachments: Attachments { type Pos = Position } = internal.attachments(tree)
+
+        /** @see [[internal.updateAttachment]] */
+        def updateAttachment[T: ClassTag](attachment: T): tree.type = internal.updateAttachment(tree, attachment)
+
+        /** @see [[internal.removeAttachment]] */
+        def removeAttachment[T: ClassTag]: tree.type = internal.removeAttachment[T](tree)
+
+        /** @see [[internal.setPos]] */
+        def setPos(newpos: Position): tree.type = internal.setPos(tree, newpos)
+
+        /** @see [[internal.setType]] */
+        def setType(tp: Type): tree.type = internal.setType(tree, tp)
+
+        /** @see [[internal.defineType]] */
+        def defineType(tp: Type): tree.type = internal.defineType(tree, tp)
+
+        /** @see [[internal.setSymbol]] */
+        def setSymbol(sym: Symbol): tree.type = internal.setSymbol(tree, sym)
+      }
+
+      /** @inheritdoc */
+      type SymbolDecorator <: MacroSymbolDecoratorApi
+
+      /** @see [[TreeDecorator]] */
+      class MacroSymbolDecoratorApi(override val symbol: Symbol) extends SymbolDecoratorApi(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)
+
+        /** @see [[internal.removeAttachment]] */
+        def removeAttachment[T: ClassTag]: symbol.type = internal.removeAttachment[T](symbol)
+
+        /** @see [[internal.setInfo]] */
+        def setInfo(tpe: Type): symbol.type = internal.setInfo(symbol, tpe)
+
+        /** @see [[internal.setAnnotations]] */
+        def setAnnotations(annots: Annotation*): symbol.type = internal.setAnnotations(symbol, annots: _*)
+
+        /** @see [[internal.setName]] */
+        def setName(name: Name): symbol.type = internal.setName(symbol, name)
+
+        /** @see [[internal.setPrivateWithin]] */
+        def setPrivateWithin(sym: Symbol): symbol.type = internal.setPrivateWithin(symbol, sym)
+      }
+    }
   }
 
   /** @group Internal */