Make things private

Author: retronym

src/compiler/scala/tools/nsc/transform/Rewrites.scala

@@ -21,7 +21,7 @@ abstract class Rewrites extends SubComponent with TypingTransformers {
       new RewritePhase(prev)
   }
 
-  class RewritePhase(prev: Phase) extends StdPhase(prev) {
+  private class RewritePhase(prev: Phase) extends StdPhase(prev) {
     override def apply(unit: CompilationUnit): Unit = {
       val patches = ArrayBuffer[Patch]()
 
@@ -35,13 +35,13 @@ abstract class Rewrites extends SubComponent with TypingTransformers {
       }
 
       val settings = global.settings
-      val rewritesSetting = settings.Yrewrites
-      if (rewritesSetting.contains(rewritesSetting.domain.breakOutArgs)) {
+      val rws = settings.Yrewrites
+      if (rws.contains(rws.domain.breakOutArgs)) {
         val rewriter = new BreakoutTraverser()
         rewriter.traverse(unit.body)
         patches ++= rewriter.patches
       }
-      if (rewritesSetting.contains(rewritesSetting.domain.collectionSeq)) {
+      if (rws.contains(rws.domain.collectionSeq)) {
         val rewriter = new CollectionSeqTransformer(treeByRangePos, unit)
         rewriter.transform(unit.body)
         patches ++= rewriter.patches
@@ -50,11 +50,11 @@ abstract class Rewrites extends SubComponent with TypingTransformers {
     }
   }
 
-  case class Patch(span: Position, replacement: String) {
+  private case class Patch(span: Position, replacement: String) {
     def delta: Int = replacement.length - (span.end - span.start)
   }
 
-  def checkNoOverlap(patches: Array[Patch]): Boolean = {
+  private def checkNoOverlap(patches: Array[Patch]): Boolean = {
     var ok = true
     if (patches.nonEmpty)
       patches.reduceLeft { (p1, p2) =>
@@ -67,7 +67,7 @@ abstract class Rewrites extends SubComponent with TypingTransformers {
     ok
   }
 
-  def applyPatches(source: SourceFile, patches: Array[Patch]): String = {
+  private def applyPatches(source: SourceFile, patches: Array[Patch]): String = {
     val sourceChars = source.content
     val patchedChars = new Array[Char](sourceChars.length + patches.foldLeft(0)(_ + _.delta))
 
@@ -91,7 +91,7 @@ abstract class Rewrites extends SubComponent with TypingTransformers {
     new String(patchedChars)
   }
 
-  def writePatches(source: SourceFile, patches: Array[Patch]): Unit = if (patches.nonEmpty) {
+  private def writePatches(source: SourceFile, patches: Array[Patch]): Unit = if (patches.nonEmpty) {
     java.util.Arrays.sort(patches, Ordering.by[Patch, Int](_.span.start))
     if (checkNoOverlap(patches)) {
       val bytes = applyPatches(source, patches).getBytes(settings.encoding.value)
@@ -101,12 +101,12 @@ abstract class Rewrites extends SubComponent with TypingTransformers {
     }
   }
 
-  lazy val breakOutSym = {
+  private lazy val breakOutSym = {
     import definitions._
     getMemberMethod(rootMirror.getPackageObject("scala.collection"), TermName("breakOut"))
   }
 
-  def isInferredArg(tree: Tree) = tree match {
+  private def isInferredArg(tree: Tree) = tree match {
     case tt: TypeTree => tt.original eq null
     case _ =>
       val pos = tree.pos
@@ -117,7 +117,7 @@ abstract class Rewrites extends SubComponent with TypingTransformers {
   }
 
   // Applied.unapply matches any tree, not just applications
-  object Application {
+  private object Application {
     def unapply(t: Tree): Option[(Tree, List[Tree], List[List[Tree]])] = t match {
       case _: Apply | _: TypeApply =>
         val applied = treeInfo.dissectApplied(t)
@@ -126,7 +126,7 @@ abstract class Rewrites extends SubComponent with TypingTransformers {
     }
   }
 
-  class BreakoutTraverser extends Traverser {
+  private class BreakoutTraverser extends Traverser {
     val patches = collection.mutable.ArrayBuffer.empty[Patch]
     override def traverse(tree: Tree): Unit = tree match {
       case Application(fun, targs, argss) if fun.symbol == breakOutSym =>
@@ -150,11 +150,6 @@ abstract class Rewrites extends SubComponent with TypingTransformers {
     val patches = collection.mutable.ArrayBuffer.empty[Patch]
     override def transform(tree: Tree): Tree = {
       tree match {
-        case tt: TypeTree if tt.original != null =>
-          val saved = tt.original.tpe
-          tt.original.tpe = tt.tpe
-          try transform(tt.original)
-          finally tt.original.setType(saved)
         case ref: RefTree =>
           for (rewrite <- rewrites) {
             val sym = ref.symbol
@@ -174,7 +169,18 @@ abstract class Rewrites extends SubComponent with TypingTransformers {
       super.transform(tree)
     }
   }
+
   private class RewriteTypingTransformer(unit: CompilationUnit) extends TypingTransformer(unit) {
+
+    override def transform(tree: Tree): Tree = tree match {
+      case tt: TypeTree if tt.original != null =>
+        val saved = tt.original.tpe
+        tt.original.tpe = tt.tpe
+        try transform(tt.original)
+        finally tt.original.setType(saved)
+      case _ => super.transform(tree)
+    }
+
     protected def localTyperParamsEntered: analyzer.Typer = {
       val typer: analyzer.Typer = localTyper
       typer.context.enclosingContextChain.filter(_.owner.isMethod).foreach { (methodContext: analyzer.Context) =>