rename selfdef into selfType

For sake of consistency with noSelfType.

2 files changed, 27 insertions, 27 deletions

diff --git a/src/reflect/scala/reflect/api/BuildUtils.scala b/src/reflect/scala/reflect/api/BuildUtils.scala
index fc5d228417..28551b1dcd 100644
--- a/src/reflect/scala/reflect/api/BuildUtils.scala
+++ b/src/reflect/scala/reflect/api/BuildUtils.scala
@@ -134,7 +134,7 @@ private[reflect] trait BuildUtils { self: Universe =>
     trait SyntacticClassDefExtractor {
       def apply(mods: Modifiers, name: TypeName, tparams: List[TypeDef],
                 constrMods: Modifiers, vparamss: List[List[ValDef]], earlyDefs: List[Tree],
-                parents: List[Tree], selfdef: ValDef, body: List[Tree]): ClassDef
+                parents: List[Tree], selfType: ValDef, body: List[Tree]): ClassDef
       def unapply(tree: Tree): Option[(Modifiers, TypeName, List[TypeDef], Modifiers, List[List[ValDef]],
                                        List[Tree], List[Tree], ValDef, List[Tree])]
     }
@@ -143,7 +143,7 @@ private[reflect] trait BuildUtils { self: Universe =>
 
     trait SyntacticTraitDefExtractor {
       def apply(mods: Modifiers, name: TypeName, tparams: List[TypeDef],
-                earlyDefs: List[Tree], parents: List[Tree], selfdef: ValDef, body: List[Tree]): ClassDef
+                earlyDefs: List[Tree], parents: List[Tree], selfType: ValDef, body: List[Tree]): ClassDef
       def unapply(tree: Tree): Option[(Modifiers, TypeName, List[TypeDef],
                                        List[Tree], List[Tree], ValDef, List[Tree])]
     }
@@ -152,7 +152,7 @@ private[reflect] trait BuildUtils { self: Universe =>
 
     trait SyntacticObjectDefExtractor {
       def apply(mods: Modifiers, name: TermName, earlyDefs: List[Tree],
-                parents: List[Tree], selfdef: ValDef, body: List[Tree]): Tree
+                parents: List[Tree], selfType: ValDef, body: List[Tree]): Tree
       def unapply(tree: Tree): Option[(Modifiers, TermName, List[Tree], List[Tree], ValDef, List[Tree])]
     }
 
@@ -160,7 +160,7 @@ private[reflect] trait BuildUtils { self: Universe =>
 
     trait SyntacticPackageObjectDefExtractor {
       def apply(name: TermName, earlyDefs: List[Tree],
-                parents: List[Tree], selfdef: ValDef, body: List[Tree]): Tree
+                parents: List[Tree], selfType: ValDef, body: List[Tree]): Tree
       def unapply(tree: Tree): Option[(TermName, List[Tree], List[Tree], ValDef, List[Tree])]
     }
 
@@ -182,7 +182,7 @@ private[reflect] trait BuildUtils { self: Universe =>
     val SyntacticNew: SyntacticNewExtractor
 
     trait SyntacticNewExtractor {
-      def apply(earlyDefs: List[Tree], parents: List[Tree], selfdef: ValDef, body: List[Tree]): Tree
+      def apply(earlyDefs: List[Tree], parents: List[Tree], selfType: ValDef, body: List[Tree]): Tree
       def unapply(tree: Tree): Option[(List[Tree], List[Tree], ValDef, List[Tree])]
     }
 
diff --git a/src/reflect/scala/reflect/internal/BuildUtils.scala b/src/reflect/scala/reflect/internal/BuildUtils.scala
index 28f353593a..b46408624c 100644
--- a/src/reflect/scala/reflect/internal/BuildUtils.scala
+++ b/src/reflect/scala/reflect/internal/BuildUtils.scala
@@ -194,9 +194,9 @@ trait BuildUtils { self: SymbolTable =>
 
     private object UnMkTemplate {
       def unapply(templ: Template): Option[(List[Tree], ValDef, Modifiers, List[List[ValDef]], List[Tree], List[Tree])] = {
-        val Template(parents, selfdef, tbody) = templ
+        val Template(parents, selfType, tbody) = templ
         def result(ctorMods: Modifiers, vparamss: List[List[ValDef]], edefs: List[Tree], body: List[Tree]) =
-          Some((parents, selfdef, ctorMods, vparamss, edefs, body))
+          Some((parents, selfType, ctorMods, vparamss, edefs, body))
         def indexOfCtor(trees: List[Tree]) =
           trees.indexWhere { case UnCtor(_, _, _) => true ; case _ => false }
 
@@ -236,7 +236,7 @@ trait BuildUtils { self: SymbolTable =>
     object SyntacticClassDef extends SyntacticClassDefExtractor {
       def apply(mods: Modifiers, name: TypeName, tparams: List[TypeDef],
                 constrMods: Modifiers, vparamss: List[List[ValDef]], earlyDefs: List[Tree],
-                parents: List[Tree], selfdef: ValDef, body: List[Tree]): ClassDef = {
+                parents: List[Tree], selfType: ValDef, body: List[Tree]): ClassDef = {
         val extraFlags = PARAMACCESSOR | (if (mods.isCase) CASEACCESSOR else 0L)
         val vparamss0 = vparamss.map { _.map { vd => copyValDef(vd)(mods = (vd.mods | extraFlags) & (~DEFERRED)) } }
         val tparams0 = mkTparams(tparams)
@@ -247,15 +247,15 @@ trait BuildUtils { self: SymbolTable =>
           } else parents
         )
         val body0 = earlyDefs ::: body
-        val templ = gen.mkTemplate(parents0, selfdef, constrMods, vparamss0, body0)
+        val templ = gen.mkTemplate(parents0, selfType, constrMods, vparamss0, body0)
         gen.mkClassDef(mods, name, tparams0, templ)
       }
 
       def unapply(tree: Tree): Option[(Modifiers, TypeName, List[TypeDef], Modifiers, List[List[ValDef]],
                                        List[Tree], List[Tree], ValDef, List[Tree])] = tree match {
-        case ClassDef(mods, name, tparams, UnMkTemplate(parents, selfdef, ctorMods, vparamss, earlyDefs, body))
+        case ClassDef(mods, name, tparams, UnMkTemplate(parents, selfType, ctorMods, vparamss, earlyDefs, body))
           if !ctorMods.isTrait && !ctorMods.hasFlag(JAVA) =>
-          Some((mods, name, tparams, ctorMods, vparamss, earlyDefs, parents, selfdef, body))
+          Some((mods, name, tparams, ctorMods, vparamss, earlyDefs, parents, selfType, body))
         case _ =>
           None
       }
@@ -263,29 +263,29 @@ trait BuildUtils { self: SymbolTable =>
 
     object SyntacticTraitDef extends SyntacticTraitDefExtractor {
       def apply(mods: Modifiers, name: TypeName, tparams: List[TypeDef], earlyDefs: List[Tree],
-                parents: List[Tree], selfdef: ValDef, body: List[Tree]): ClassDef = {
+                parents: List[Tree], selfType: ValDef, body: List[Tree]): ClassDef = {
         val mods0 = mods | TRAIT | ABSTRACT
-        val templ = gen.mkTemplate(parents, selfdef, Modifiers(TRAIT), Nil, earlyDefs ::: body)
+        val templ = gen.mkTemplate(parents, selfType, Modifiers(TRAIT), Nil, earlyDefs ::: body)
         gen.mkClassDef(mods0, name, mkTparams(tparams), templ)
       }
 
       def unapply(tree: Tree): Option[(Modifiers, TypeName, List[TypeDef],
                                        List[Tree], List[Tree], ValDef, List[Tree])] = tree match {
-        case ClassDef(mods, name, tparams, UnMkTemplate(parents, selfdef, ctorMods, vparamss, earlyDefs, body))
+        case ClassDef(mods, name, tparams, UnMkTemplate(parents, selfType, ctorMods, vparamss, earlyDefs, body))
           if mods.isTrait =>
-          Some((mods, name, tparams, earlyDefs, parents, selfdef, body))
+          Some((mods, name, tparams, earlyDefs, parents, selfType, body))
         case _ => None
       }
     }
 
     object SyntacticObjectDef extends SyntacticObjectDefExtractor {
       def apply(mods: Modifiers, name: TermName, earlyDefs: List[Tree],
-                parents: List[Tree], selfdef: ValDef, body: List[Tree]) =
-        ModuleDef(mods, name, gen.mkTemplate(parents, selfdef, NoMods, Nil, earlyDefs ::: body))
+                parents: List[Tree], selfType: ValDef, body: List[Tree]) =
+        ModuleDef(mods, name, gen.mkTemplate(parents, selfType, NoMods, Nil, earlyDefs ::: body))
 
       def unapply(tree: Tree): Option[(Modifiers, TermName, List[Tree], List[Tree], ValDef, List[Tree])] = tree match {
-        case ModuleDef(mods, name, UnMkTemplate(parents, selfdef, _, _, earlyDefs, body)) =>
-          Some((mods, name, earlyDefs, parents, selfdef, body))
+        case ModuleDef(mods, name, UnMkTemplate(parents, selfType, _, _, earlyDefs, body)) =>
+          Some((mods, name, earlyDefs, parents, selfType, body))
         case _ =>
           None
       }
@@ -293,12 +293,12 @@ trait BuildUtils { self: SymbolTable =>
 
     object SyntacticPackageObjectDef extends SyntacticPackageObjectDefExtractor {
       def apply(name: TermName, earlyDefs: List[Tree],
-                parents: List[Tree], selfdef: ValDef, body: List[Tree]): Tree =
-        gen.mkPackageObject(SyntacticObjectDef(NoMods, name, earlyDefs, parents, selfdef, body))
+                parents: List[Tree], selfType: ValDef, body: List[Tree]): Tree =
+        gen.mkPackageObject(SyntacticObjectDef(NoMods, name, earlyDefs, parents, selfType, body))
 
       def unapply(tree: Tree): Option[(TermName, List[Tree], List[Tree], ValDef, List[Tree])] = tree match {
-        case PackageDef(Ident(name: TermName), List(SyntacticObjectDef(NoMods, nme.PACKAGEkw, earlyDefs, parents, selfdef, body))) =>
-          Some((name, earlyDefs, parents, selfdef, body))
+        case PackageDef(Ident(name: TermName), List(SyntacticObjectDef(NoMods, nme.PACKAGEkw, earlyDefs, parents, selfType, body))) =>
+          Some((name, earlyDefs, parents, selfType, body))
         case _ =>
           None
       }
@@ -406,15 +406,15 @@ trait BuildUtils { self: SymbolTable =>
     }
 
     object SyntacticNew extends SyntacticNewExtractor {
-      def apply(earlyDefs: List[Tree], parents: List[Tree], selfdef: ValDef, body: List[Tree]): Tree =
-        gen.mkNew(parents, selfdef, earlyDefs ::: body, NoPosition, NoPosition)
+      def apply(earlyDefs: List[Tree], parents: List[Tree], selfType: ValDef, body: List[Tree]): Tree =
+        gen.mkNew(parents, selfType, earlyDefs ::: body, NoPosition, NoPosition)
 
       def unapply(tree: Tree): Option[(List[Tree], List[Tree], ValDef, List[Tree])] = tree match {
         case SyntacticApplied(Select(New(SyntacticTypeApplied(ident, targs)), nme.CONSTRUCTOR), argss) =>
           Some((Nil, SyntacticApplied(SyntacticTypeApplied(ident, targs), argss) :: Nil, noSelfType, Nil))
-        case SyntacticBlock(SyntacticClassDef(_, tpnme.ANON_CLASS_NAME, Nil, _, ListOfNil, earlyDefs, parents, selfdef, body) ::
+        case SyntacticBlock(SyntacticClassDef(_, tpnme.ANON_CLASS_NAME, Nil, _, ListOfNil, earlyDefs, parents, selfType, body) ::
                             Apply(Select(New(Ident(tpnme.ANON_CLASS_NAME)), nme.CONSTRUCTOR), Nil) :: Nil) =>
-          Some((earlyDefs, parents, selfdef, body))
+          Some((earlyDefs, parents, selfType, body))
         case _ =>
           None
       }