SI-7624 Fix -feature warnings in scala/tools/scalap

... and move scalap.scala.tools.scalap.scalax.rules to
scalap.scala.tools.scalap.rules now that all the Monad/Functor/
Applicatve/... stuff has been removed.

Author: soc

src/partest/scala/tools/partest/nest/Runner.scala

@@ -20,7 +20,7 @@ import scala.tools.nsc.{ Settings, CompilerCommand, Global }
 import scala.tools.nsc.reporters.ConsoleReporter
 import scala.tools.nsc.util.{ Exceptional, ScalaClassLoader, stackTraceString }
 import scala.tools.scalap.Main.decompileScala
-import scala.tools.scalap.scalax.rules.scalasig.ByteCode
+import scala.tools.scalap.scalasig.ByteCode
 import scala.util.{ Try, Success, Failure }
 import ClassPath.{ join, split }
 import PartestDefaults.{ javaCmd, javacCmd }

src/scalap/scala/tools/scalap/Arguments.scala

@@ -5,7 +5,6 @@
 **
 */
 
-
 package scala.tools.scalap
 
 import scala.collection.mutable

src/scalap/scala/tools/scalap/ByteArrayReader.scala

@@ -5,10 +5,7 @@
 **
 */
 
-
-package scala
-package tools.scalap
-
+package scala.tools.scalap
 
 class ByteArrayReader(content: Array[Byte]) {
 
@@ -104,9 +101,6 @@ class ByteArrayReader(content: Array[Byte]) {
   def getDouble(bp: Int): Double = java.lang.Double.longBitsToDouble(getLong(bp))
 
    /** skip next 'n' bytes
-  */
-  def skip(n: Int) {
-    bp += n
-  }
-
+    */
+  def skip(n: Int): Unit = bp += n
 }

src/scalap/scala/tools/scalap/Classfile.scala

@@ -5,10 +5,8 @@
 **
 */
 
-
 package scala.tools.scalap
 
-
 class Classfile(in: ByteArrayReader) {
   import Classfiles._
 

src/scalap/scala/tools/scalap/Classfiles.scala

@@ -5,10 +5,8 @@
 **
 */
 
-
 package scala.tools.scalap
 
-
 object Classfiles {
   final val JAVA_MAGIC = 0xCAFEBABE
   final val JAVA_MAJOR_VERSION = 45

src/scalap/scala/tools/scalap/CodeWriter.scala

@@ -6,13 +6,9 @@
 */
 
 
-package scala
-package tools.scalap
+package scala.tools.scalap
 
-import java.io._
-
-
-class CodeWriter(writer: Writer) {
+class CodeWriter(writer: java.io.Writer) {
 
   private val nl = scala.compat.Platform.EOL
   private var step = "  "

src/scalap/scala/tools/scalap/Decode.scala

@@ -5,17 +5,14 @@
 **
 */
 
-// $Id$
-
 package scala.tools.scalap
 
-import scala.tools.scalap.scalax.rules.scalasig._
-import scala.tools.nsc.util.ScalaClassLoader
-import scala.tools.nsc.util.ScalaClassLoader.appLoader
+import scala.tools.scalap.scalasig._
+
+import scala.reflect.internal.util.ScalaClassLoader
 import scala.reflect.internal.pickling.ByteCodecs
 
 import ClassFileParser.{ ConstValueIndex, Annotation }
-import Main.{ SCALA_SIG, SCALA_SIG_ANNOTATION, BYTES_VALUE }
 
 /** Temporary decoder.  This would be better off in the scala.tools.nsc
  *  but right now the compiler won't acknowledge scala.tools.scalap
@@ -31,25 +28,24 @@ object Decode {
   /** Return the classfile bytes representing the scala sig classfile attribute.
    *  This has been obsoleted by the switch to annotations.
    */
-  def scalaSigBytes(name: String): Option[Array[Byte]] = scalaSigBytes(name, appLoader)
+  def scalaSigBytes(name: String): Option[Array[Byte]] = scalaSigBytes(name, ScalaClassLoader.appLoader)
   def scalaSigBytes(name: String, classLoader: ScalaClassLoader): Option[Array[Byte]] = {
     val bytes = classLoader.classBytes(name)
     val reader = new ByteArrayReader(bytes)
     val cf = new Classfile(reader)
     cf.scalaSigAttribute map (_.data)
   }
 
-  /** Return the bytes representing the annotation
-   */
-  def scalaSigAnnotationBytes(name: String): Option[Array[Byte]] = scalaSigAnnotationBytes(name, appLoader)
+  /** Return the bytes representing the annotation. */
+  def scalaSigAnnotationBytes(name: String): Option[Array[Byte]] = scalaSigAnnotationBytes(name, ScalaClassLoader.appLoader)
   def scalaSigAnnotationBytes(name: String, classLoader: ScalaClassLoader): Option[Array[Byte]] = {
     val bytes     = classLoader.classBytes(name)
     val byteCode  = ByteCode(bytes)
     val classFile = ClassFileParser.parse(byteCode)
     import classFile._
 
-    classFile annotation SCALA_SIG_ANNOTATION map { case Annotation(_, els) =>
-      val bytesElem = els find (x => constant(x.elementNameIndex) == BYTES_VALUE) getOrElse null
+    classFile annotation Main.SCALA_SIG_ANNOTATION map { case Annotation(_, els) =>
+      val bytesElem = els find (x => constant(x.elementNameIndex) == Main.BYTES_VALUE) getOrElse null
       val _bytes    = bytesElem.elementValue match { case ConstValueIndex(x) => constantWrapped(x) }
       val bytes     = _bytes.asInstanceOf[StringBytesPair].bytes
       val length    = ByteCodecs.decode(bytes)
@@ -58,16 +54,15 @@ object Decode {
     }
   }
 
-  /** private[scala] so nobody gets the idea this is a supported interface.
-   */
+  /** private[scala] so nobody gets the idea this is a supported interface. */
   private[scala] def caseParamNames(path: String): Option[List[String]] = {
     val (outer, inner) = (path indexOf '$') match {
       case -1   => (path, "")
       case x    => (path take x, path drop (x + 1))
     }
 
     for {
-      clazz <- appLoader.tryToLoadClass[AnyRef](outer)
+      clazz <- ScalaClassLoader.appLoader.tryToLoadClass[AnyRef](outer)
       ssig <- ScalaSigParser.parse(clazz)
     }
     yield {
@@ -85,11 +80,10 @@ object Decode {
     }
   }
 
-  /** Returns a map of Alias -> Type for the given package.
-   */
+  /** Returns a map of Alias -> Type for the given package. */
   private[scala] def typeAliases(pkg: String) = {
     for {
-      clazz <- appLoader.tryToLoadClass[AnyRef](pkg + ".package")
+      clazz <- ScalaClassLoader.appLoader.tryToLoadClass[AnyRef](pkg + ".package")
       ssig <- ScalaSigParser.parse(clazz)
     }
     yield {

src/scalap/scala/tools/scalap/JavaWriter.scala

@@ -5,13 +5,11 @@
 **
 */
 
-
 package scala.tools.scalap
 
-import java.io._
 import scala.reflect.NameTransformer
 
-class JavaWriter(classfile: Classfile, writer: Writer) extends CodeWriter(writer) {
+class JavaWriter(classfile: Classfile, writer: java.io.Writer) extends CodeWriter(writer) {
 
   val cf = classfile
 

src/scalap/scala/tools/scalap/Main.scala

@@ -5,17 +5,17 @@
 **
 */
 
-package scala
-package tools.scalap
+package scala.tools.scalap
 
 import java.io.{ PrintStream, OutputStreamWriter, ByteArrayOutputStream }
-import scala.reflect.NameTransformer
-import scalax.rules.scalasig._
+
 import scala.tools.nsc.util.{ ClassPath, JavaClassPath }
-import scala.tools.util.PathResolver
-import ClassPath.DefaultJavaContext
+import scala.tools.nsc.util.ClassPath.DefaultJavaContext
 import scala.tools.nsc.io.AbstractFile
 
+import scala.tools.scalap.scalasig._
+
+
 /**The main object used to execute scalap on the command-line.
  *
  * @author Matthias Zenger, Stephane Micheloud, Burak Emir, Ilya Sergey
@@ -104,7 +104,7 @@ class Main {
         // we have to encode every fragment of a name separately, otherwise the NameTransformer
         // will encode using unicode escaping dot separators as well
         // we can afford allocations because this is not a performance critical code
-        classname.split('.').map(NameTransformer.encode).mkString(".")
+        classname.split('.').map(scala.reflect.NameTransformer.encode).mkString(".")
     }
     val cls = path.findClass(encName)
     if (cls.isDefined && cls.get.binary.isDefined) {
@@ -185,7 +185,7 @@ object Main extends Main {
     val cparg = List("-classpath", "-cp") map (arguments getArgument _) reduceLeft (_ orElse _)
     val path = cparg match {
       case Some(cp) => new JavaClassPath(DefaultJavaContext.classesInExpandedPath(cp), DefaultJavaContext)
-      case _        => PathResolver.fromPathString(".") // include '.' in the default classpath SI-6669
+      case _        => scala.tools.util.PathResolver.fromPathString(".") // include '.' in the default classpath SI-6669
     }
     // print the classpath if output is verbose
     if (verbose)

src/scalap/scala/tools/scalap/MetaParser.scala

@@ -6,17 +6,15 @@
 */
 
 
-package scala
-package tools.scalap
+package scala.tools.scalap
 
-import java.util._
 
 
 /** a parser class for parsing meta type information in classfiles
  *  generated by pico.
  */
 class MetaParser(meta: String) {
-  val scanner = new StringTokenizer(meta, "()[], \t<;", true)
+  val scanner = new java.util.StringTokenizer(meta, "()[], \t<;", true)
   var token: String = _
   val res = new StringBuffer
 

src/scalap/scala/tools/scalap/Properties.scala

@@ -9,8 +9,7 @@
 package scala.tools.scalap
 
 /** Loads decoder.properties from the jar. */
-object Properties extends scala.util.PropertiesTrait
-{
+object Properties extends scala.util.PropertiesTrait {
   protected def propCategory    = "decoder"
   protected def pickJarBasedOn  = classOf[Classfile]
 }

src/scalap/scala/tools/scalap/scalax/rules/Memoisable.scala renamed to src/scalap/scala/tools/scalap/rules/Memoisable.scala

@@ -10,9 +10,7 @@
 //
 // -----------------------------------------------------------------------------
 
-package scala.tools.scalap
-package scalax
-package rules
+package scala.tools.scalap.rules
 
 import scala.collection.mutable
 
@@ -22,7 +20,7 @@ trait MemoisableRules extends Rules {
     from[In] { in => in.memo(key, rule(in)) }
   }
 
-  override def ruleWithName[In, Out, A, X](name : String, f : In => rules.Result[Out, A, X]) = super.ruleWithName(name, (in : In) => in match {
+  override def ruleWithName[In, Out, A, X](name : String, f : In => Result[Out, A, X]) = super.ruleWithName(name, (in : In) => in match {
       case s : Memoisable => s.memo(name, f(in))
       case _ => f(in)
     })
@@ -56,6 +54,3 @@ trait DefaultMemoisable extends Memoisable {
     if(DefaultMemoisable.debug) println(key + " -> " + t + " (" + out + ")")
   }
 }
-
-
-

src/scalap/scala/tools/scalap/scalax/rules/Result.scala renamed to src/scalap/scala/tools/scalap/rules/Result.scala

@@ -10,9 +10,7 @@
 //
 // -----------------------------------------------------------------------------
 
-package scala.tools.scalap
-package scalax
-package rules;
+package scala.tools.scalap.rules;
 
 /** Represents the combined value of two rules applied in sequence.
  *

src/scalap/scala/tools/scalap/scalax/rules/Rule.scala renamed to src/scalap/scala/tools/scalap/rules/Rule.scala

@@ -10,9 +10,7 @@
 //
 // -----------------------------------------------------------------------------
 
-package scala.tools.scalap
-package scalax
-package rules
+package scala.tools.scalap.rules
 
 /** A Rule is a function from some input to a Result.  The result may be:
   * <ul>
@@ -91,11 +89,11 @@ trait Rule[-In, +Out, +A, +X] extends (In => Result[Out, A, X]) {
   /** Apply the result of this rule to the function returned by the previous rule */
   def <~:[InPrev, B, X2 >: X](prev : => Rule[InPrev, In, A => B, X2]) = for (fa2b <- prev; a <- this) yield fa2b(a)
 
-  def ~![Out2, B, X2 >: X](next : => Rule[Out, Out2, B, X2]) = for (a <- this; b <- next orError) yield new ~(a, b)
+  def ~![Out2, B, X2 >: X](next : => Rule[Out, Out2, B, X2]) = for (a <- this; b <- next.orError) yield new ~(a, b)
 
-  def ~-![Out2, B, X2 >: X](next : => Rule[Out, Out2, B, X2]) = for (a <- this; b <- next orError) yield a
+  def ~-![Out2, B, X2 >: X](next : => Rule[Out, Out2, B, X2]) = for (a <- this; b <- next.orError) yield a
 
-  def -~![Out2, B, X2 >: X](next : => Rule[Out, Out2, B, X2]) = for (a <- this; b <- next orError) yield b
+  def -~![Out2, B, X2 >: X](next : => Rule[Out, Out2, B, X2]) = for (a <- this; b <- next.orError) yield b
 
   def -[In2 <: In](exclude : => Rule[In2, Any, Any, Any]) = !exclude -~ this
 
@@ -172,6 +170,3 @@ trait Choice[-In, +Out, +A, +X] extends Rule[In, Out, A, X] {
     lazy val choices = Choice.this.choices ::: other :: Nil
   }
 }
-
-
-

src/scalap/scala/tools/scalap/scalax/rules/Rules.scala renamed to src/scalap/scala/tools/scalap/rules/Rules.scala

@@ -11,7 +11,6 @@
 // -----------------------------------------------------------------------------
 
 package scala.tools.scalap
-package scalax
 package rules
 
 trait Name {
@@ -26,12 +25,17 @@ trait Name {
   * Inspired by the Scala parser combinator.
   */
 trait Rules {
-  implicit def rule[In, Out, A, X](f : In => Result[Out, A, X]) : Rule[In, Out, A, X] = new DefaultRule(f)
 
+  import scala.language.implicitConversions
+  implicit def rule[In, Out, A, X](f : In => Result[Out, A, X]) : Rule[In, Out, A, X] = new DefaultRule(f)
   implicit def inRule[In, Out, A, X](rule : Rule[In, Out, A, X]) : InRule[In, Out, A, X] = new InRule(rule)
   implicit def seqRule[In, A, X](rule : Rule[In, In, A, X]) : SeqRule[In, A, X] = new SeqRule(rule)
 
-  def from[In] = new {
+  trait FromRule[In] {
+    def apply[Out, A, X](f : In => Result[Out, A, X]): Rule[In, Out, A, X]
+  }
+
+  def from[In] = new FromRule[In] {
     def apply[Out, A, X](f : In => Result[Out, A, X]) = rule(f)
   }
 

src/scalap/scala/tools/scalap/scalax/rules/SeqRule.scala renamed to src/scalap/scala/tools/scalap/rules/SeqRule.scala

@@ -10,9 +10,7 @@
 //
 // -----------------------------------------------------------------------------
 
-package scala.tools.scalap
-package scalax
-package rules
+package scala.tools.scalap.rules
 
 /**
  * A workaround for the difficulties of dealing with
@@ -49,7 +47,7 @@ class SeqRule[S, +A, +X](rule : Rule[S, S, A, X]) {
 
   /** Creates a rule that always succeeds with a Boolean value.
    *  Value is 'true' if this rule succeeds, 'false' otherwise */
-  def -? = ? map { _ isDefined }
+  def -? = ? map { _.isDefined }
 
   def * = from[S] {
     // tail-recursive function with reverse list accumulator
@@ -98,4 +96,3 @@ class SeqRule[S, +A, +X](rule : Rule[S, S, A, X]) {
     in => rep(0, in)
   }
 }
-

src/scalap/scala/tools/scalap/rules/package.scala

@@ -0,0 +1,6 @@
+package scala.tools.scalap
+
+package object rules {
+  // make some language features in this package compile without warning
+  implicit def postfixOps = scala.language.postfixOps
+}