no postfixops in reflect

Author: som-snytt

src/reflect/scala/reflect/internal/AnnotationInfos.scala

@@ -16,7 +16,6 @@ package internal
 
 import scala.annotation.tailrec
 import scala.collection.immutable.ListMap
-import scala.language.postfixOps
 
 /** AnnotationInfo and its helpers */
 trait AnnotationInfos extends api.Annotations { self: SymbolTable =>
@@ -339,7 +338,7 @@ trait AnnotationInfos extends api.Annotations { self: SymbolTable =>
     case Apply(Select(New(tpt), nme.CONSTRUCTOR), args) =>
       def encodeJavaArg(arg: Tree): ClassfileAnnotArg = arg match {
         case Literal(const) => LiteralAnnotArg(const)
-        case Apply(ArrayModule, args) => ArrayAnnotArg(args map encodeJavaArg toArray)
+        case Apply(ArrayModule, args) => ArrayAnnotArg(args.map(encodeJavaArg).toArray)
         case Apply(Select(New(tpt), nme.CONSTRUCTOR), args) => NestedAnnotArg(treeToAnnotation(arg))
         case _ => throw new Exception(s"unexpected java argument shape $arg: literals, arrays and nested annotations are supported")
       }

src/reflect/scala/reflect/internal/Chars.scala

@@ -14,8 +14,6 @@ package scala
 package reflect
 package internal
 
-import scala.language.postfixOps
-
 import scala.annotation.switch
 import java.lang.{ Character => JCharacter }
 
@@ -49,8 +47,7 @@ trait Chars {
 
   /** Convert a character to a backslash-u escape */
   def char2uescape(c: Char): String = {
-    @inline def hexChar(ch: Int): Char =
-      ( if (ch < 10) '0' else 'A' - 10 ) + ch toChar
+    @inline def hexChar(ch: Int): Char = ((if (ch < 10) '0' else 'A' - 10) + ch).toChar
 
     char2uescapeArray(2) = hexChar((c >> 12)     )
     char2uescapeArray(3) = hexChar((c >>  8) % 16)

src/reflect/scala/reflect/internal/Definitions.scala

@@ -14,7 +14,6 @@ package scala
 package reflect
 package internal
 
-import scala.language.postfixOps
 import scala.annotation.{meta, migration}
 import scala.collection.mutable
 import Flags._
@@ -37,13 +36,13 @@ trait Definitions extends api.StandardDefinitions {
 
   private def enterNewClass(owner: Symbol, name: TypeName, parents: List[Type], flags: Long = 0L): ClassSymbol = {
     val clazz = owner.newClassSymbol(name, NoPosition, flags)
-    clazz setInfoAndEnter ClassInfoType(parents, newScope, clazz) markAllCompleted
+    clazz.setInfoAndEnter(ClassInfoType(parents, newScope, clazz)).markAllCompleted
   }
   private def newMethod(owner: Symbol, name: TermName, formals: List[Type], restpe: Type, flags: Long): MethodSymbol = {
     val msym   = owner.newMethod(name.encode, NoPosition, flags)
     val params = msym.newSyntheticValueParams(formals)
     val info = if (owner.isJavaDefined) JavaMethodType(params, restpe) else MethodType(params, restpe)
-    msym setInfo info markAllCompleted
+    msym.setInfo(info).markAllCompleted
   }
   private def enterNewMethod(owner: Symbol, name: TermName, formals: List[Type], restpe: Type, flags: Long = 0L): MethodSymbol =
     owner.info.decls enter newMethod(owner, name, formals, restpe, flags)
@@ -288,8 +287,8 @@ trait Definitions extends api.StandardDefinitions {
     }
 
     // top types
-    lazy val AnyClass    = enterNewClass(ScalaPackageClass, tpnme.Any, Nil, ABSTRACT) markAllCompleted
-    lazy val AnyRefClass = newAlias(ScalaPackageClass, tpnme.AnyRef, ObjectTpe) markAllCompleted
+    lazy val AnyClass    = enterNewClass(ScalaPackageClass, tpnme.Any, Nil, ABSTRACT).markAllCompleted
+    lazy val AnyRefClass = newAlias(ScalaPackageClass, tpnme.AnyRef, ObjectTpe).markAllCompleted
     lazy val ObjectClass = getRequiredClass(sn.Object.toString)
 
     // Cached types for core monomorphic classes
@@ -312,7 +311,7 @@ trait Definitions extends api.StandardDefinitions {
       val anyval    = enterNewClass(ScalaPackageClass, tpnme.AnyVal, AnyTpe :: Nil, ABSTRACT)
       val av_constr = anyval.newClassConstructor(NoPosition)
       anyval.info.decls enter av_constr
-      anyval markAllCompleted
+      anyval.markAllCompleted
     }).asInstanceOf[ClassSymbol]
       def AnyVal_getClass = getMemberMethod(AnyValClass, nme.getClass_)
 
@@ -324,7 +323,7 @@ trait Definitions extends api.StandardDefinitions {
       locally {
         this initFlags ABSTRACT | FINAL
         this setInfoAndEnter ClassInfoType(List(parent.tpe), newScope, this)
-        this markAllCompleted
+        this.markAllCompleted
       }
       final override def isBottomClass = true
       final override def isThreadsafe(purpose: SymbolOps): Boolean = true
@@ -397,7 +396,7 @@ trait Definitions extends api.StandardDefinitions {
       def delayedInitMethod = getMemberMethod(DelayedInitClass, nme.delayedInit)
 
     lazy val TypeConstraintClass   = requiredClass[scala.annotation.TypeConstraint]
-    lazy val SingletonClass        = enterNewClass(ScalaPackageClass, tpnme.Singleton, AnyTpe :: Nil, ABSTRACT | TRAIT | FINAL) markAllCompleted
+    lazy val SingletonClass        = enterNewClass(ScalaPackageClass, tpnme.Singleton, AnyTpe :: Nil, ABSTRACT | TRAIT | FINAL).markAllCompleted
     lazy val SerializableClass     = requiredClass[java.io.Serializable] modifyInfo fixupAsAnyTrait
     lazy val ComparableClass       = requiredClass[java.lang.Comparable[_]] modifyInfo fixupAsAnyTrait
     lazy val JavaCloneableClass    = requiredClass[java.lang.Cloneable] modifyInfo fixupAsAnyTrait
@@ -1307,7 +1306,7 @@ trait Definitions extends api.StandardDefinitions {
       // Trying to allow for deprecated locations
       sym.isAliasType && isMetaAnnotation(sym.info.typeSymbol)
     )
-    lazy val metaAnnotations: Set[Symbol] = getPackage(TermName("scala.annotation.meta")).info.members filter (_ isSubClass StaticAnnotationClass) toSet
+    lazy val metaAnnotations: Set[Symbol] = getPackage(TermName("scala.annotation.meta")).info.members.filter(_ isSubClass StaticAnnotationClass).toSet
 
     // According to the scala.annotation.meta package object:
     // * By default, annotations on (`val`-, `var`- or plain) constructor parameters
@@ -1432,7 +1431,7 @@ trait Definitions extends api.StandardDefinitions {
       val tparam  = clazz.newSyntheticTypeParam("T0", flags)
       val parents = List(AnyRefTpe, parentFn(tparam))
 
-      clazz setInfo GenPolyType(List(tparam), ClassInfoType(parents, newScope, clazz)) markAllCompleted
+      clazz.setInfo(GenPolyType(List(tparam), ClassInfoType(parents, newScope, clazz))).markAllCompleted
     }
 
     def newPolyMethod(typeParamCount: Int, owner: Symbol, name: TermName, flags: Long)(createFn: PolyMethodCreator): MethodSymbol = {
@@ -1443,7 +1442,7 @@ trait Definitions extends api.StandardDefinitions {
         case (_, restpe)             => NullaryMethodType(restpe)
       }
 
-      msym setInfoAndEnter genPolyType(tparams, mtpe) markAllCompleted
+      msym.setInfoAndEnter(genPolyType(tparams, mtpe)).markAllCompleted
     }
 
     /** T1 means one type parameter.

src/reflect/scala/reflect/internal/util/TableDef.scala

@@ -15,7 +15,6 @@ package reflect.internal.util
 
 import TableDef._
 import scala.collection.immutable.AbstractSeq
-import scala.language.postfixOps
 
 /** A class for representing tabular data in a way that preserves
  *  its inner beauty.
@@ -45,7 +44,7 @@ class TableDef[T](_cols: Column[T]*) {
     def apply(index: Int) = rows(index)
     def length            = rows.length
 
-    def maxColWidth(col: Column[T]) = col.name +: (rows map col.f) map (_.toString.length) max
+    def maxColWidth(col: Column[T]) = (col.name +: rows.map(col.f)).map(_.toString.length).max
     def specs = cols map (_ formatSpec rows)
 
     val colWidths   = cols map maxColWidth
@@ -59,7 +58,7 @@ class TableDef[T](_cols: Column[T]*) {
     )
 
     def mkFormatString(sepf: Int => String): String =
-      specs.zipWithIndex map { case (c, i) => c + sepf(i) } mkString
+      specs.zipWithIndex.map { case (c, i) => c + sepf(i) }.mkString
 
     def toFormattedSeq = argLists map (xs => rowFormat.format(xs: _*))
     def allToSeq = headers ++ toFormattedSeq
@@ -74,7 +73,7 @@ class TableDef[T](_cols: Column[T]*) {
 
 object TableDef {
   case class Column[-T](name: String, f: T => Any, left: Boolean) {
-    def maxWidth(elems: Seq[T]): Int = name +: (elems map f) map (_.toString.length) max
+    def maxWidth(elems: Seq[T]): Int = (name +: elems.map(f)).map(_.toString.length).max
     def formatSpec(elems: Seq[T]): String = {
       val justify = if (left) "-" else ""
       "%" + justify + maxWidth(elems) + "s"