Members removed in the backend.

17 files changed, 4 insertions, 247 deletions

diff --git a/src/compiler/scala/tools/nsc/backend/icode/BasicBlocks.scala b/src/compiler/scala/tools/nsc/backend/icode/BasicBlocks.scala
index 7c7777f761..34bdc1ede4 100644
--- a/src/compiler/scala/tools/nsc/backend/icode/BasicBlocks.scala
+++ b/src/compiler/scala/tools/nsc/backend/icode/BasicBlocks.scala
@@ -280,14 +280,6 @@ trait BasicBlocks {
       }
     }
 
-    /** Insert instructions in 'is' immediately after index 'idx'. */
-    def insertAfter(idx: Int, is: List[Instruction]) {
-      assert(closed, "Instructions can be replaced only after the basic block is closed")
-
-      instrs = instrs.patch(idx + 1, is, 0)
-      code.touched = true
-    }
-
     /** Removes instructions found at the given positions.
      */
     def removeInstructionsAt(positions: Int*) {
@@ -335,10 +327,6 @@ trait BasicBlocks {
      *  is closed, which sets the DIRTYSUCCS flag.
      */
     def emit(instr: Instruction, pos: Position) {
-/*      if (closed) {
-        print()
-        Console.println("trying to emit: " + instr)
-      } */
       assert(!closed || ignore, this)
 
       if (ignore) {
@@ -432,11 +420,6 @@ trait BasicBlocks {
       ignore = true
     }
 
-    def exitIgnoreMode() {
-      assert(ignore, "Exit ignore mode when not in ignore mode: " + this)
-      ignore = false
-    }
-
     /** Return the last instruction of this basic block. */
     def lastInstruction =
       if (closed) instrs(instrs.length - 1)
@@ -493,17 +476,6 @@ trait BasicBlocks {
 
     override def hashCode = label * 41 + code.hashCode
 
-    // Instead of it, rather use a printer
-    def print() { print(java.lang.System.out) }
-
-    def print(out: java.io.PrintStream) {
-      out.println("block #"+label+" :")
-      foreach(i => out.println("  " + i))
-      out.print("Successors: ")
-      successors.foreach((x: BasicBlock) => out.print(" "+x.label.toString()))
-      out.println()
-    }
-
     private def succString = if (successors.isEmpty) "[S: N/A]" else successors.distinct.mkString("[S: ", ", ", "]")
     private def predString = if (predecessors.isEmpty) "[P: N/A]" else predecessors.distinct.mkString("[P: ", ", ", "]")
 
diff --git a/src/compiler/scala/tools/nsc/backend/icode/ExceptionHandlers.scala b/src/compiler/scala/tools/nsc/backend/icode/ExceptionHandlers.scala
index f35996eeb9..7c2961778f 100644
--- a/src/compiler/scala/tools/nsc/backend/icode/ExceptionHandlers.scala
+++ b/src/compiler/scala/tools/nsc/backend/icode/ExceptionHandlers.scala
@@ -71,10 +71,4 @@ trait ExceptionHandlers {
     override def toString() = "finalizer_" + label
     override def dup: Finalizer = new Finalizer(method, label, pos)
   }
-
-  object NoFinalizer extends Finalizer(null, newTermNameCached("<no finalizer>"), NoPosition) {
-    override def startBlock: BasicBlock             = sys.error("NoFinalizer cannot have a start block.");
-    override def setStartBlock(b: BasicBlock): Unit = sys.error("NoFinalizer cannot have a start block.");
-    override def dup = this
-  }
 }
diff --git a/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala b/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala
index e2436d0e90..61d0292707 100644
--- a/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala
+++ b/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala
@@ -1946,13 +1946,6 @@ abstract class GenICode extends SubComponent  {
         this
       }
 
-      def removeFinalizer(f: Tree): this.type = {
-        assert(cleanups.head contains f,
-               "Illegal nesting of cleanup operations: " + cleanups + " while exiting finalizer " + f);
-        cleanups = cleanups.tail
-        this
-      }
-
       /** Prepare a new context upon entry into a method.
        */
       def enterMethod(m: IMethod, d: DefDef): Context = {
@@ -2025,16 +2018,6 @@ abstract class GenICode extends SubComponent  {
         currentExceptionHandlers = currentExceptionHandlers.tail
       }
 
-      /** Remove the given handler from the list of active exception handlers. */
-      def removeActiveHandler(exh: ExceptionHandler): Unit = {
-        assert(handlerCount > 0 && handlers.head == exh,
-               "Wrong nesting of exception handlers." + this + " for " + exh)
-        handlerCount -= 1
-        handlers = handlers.tail
-        debuglog("removed handler: " + exh);
-
-      }
-
       /** Clone the current context */
       def dup: Context = new Context(this)
 
@@ -2321,7 +2304,6 @@ abstract class GenICode extends SubComponent  {
     val locals: ListBuffer[Local] = new ListBuffer
 
     def add(l: Local)     = locals += l
-    def remove(l: Local)  = locals -= l
 
     /** Return all locals that are in scope. */
     def varsInScope: Buffer[Local] = outer.varsInScope.clone() ++= locals
diff --git a/src/compiler/scala/tools/nsc/backend/icode/Members.scala b/src/compiler/scala/tools/nsc/backend/icode/Members.scala
index 07abe9d74f..12daa32186 100644
--- a/src/compiler/scala/tools/nsc/backend/icode/Members.scala
+++ b/src/compiler/scala/tools/nsc/backend/icode/Members.scala
@@ -126,9 +126,7 @@ trait Members {
 
     override def toString() = symbol.fullName
 
-    def lookupField(s: Symbol)  = fields find (_.symbol == s)
     def lookupMethod(s: Symbol) = methods find (_.symbol == s)
-    def lookupMethod(s: Name)   = methods find (_.symbol.name == s)
 
     /* returns this methods static ctor if it has one. */
     def lookupStaticCtor: Option[IMethod] = methods find (_.symbol.isStaticConstructor)
@@ -159,7 +157,6 @@ trait Members {
     def linearizedBlocks(lin: Linearizer = self.linearizer): List[BasicBlock] = lin linearize this
 
     def foreachBlock[U](f: BasicBlock  => U): Unit = blocks foreach f
-    def foreachInstr[U](f: Instruction => U): Unit = foreachBlock(_.toList foreach f)
 
     var native = false
 
@@ -192,7 +189,6 @@ trait Members {
       }
 
     def addLocals(ls: List[Local]) = ls foreach addLocal
-    def addParams(as: List[Local]) = as foreach addParam
 
     def lookupLocal(n: Name): Option[Local]     = locals find (_.sym.name == n)
     def lookupLocal(sym: Symbol): Option[Local] = locals find (_.sym == sym)
@@ -207,28 +203,7 @@ trait Members {
 
     override def toString() = symbol.fullName
 
-    def matchesSignature(other: IMethod) = {
-      (symbol.name == other.symbol.name) &&
-      (params corresponds other.params)(_.kind == _.kind) &&
-      (returnType == other.returnType)
-    }
-
     import opcodes._
-    def checkLocals(): Unit = {
-      def localsSet = (code.blocks flatMap { bb =>
-        bb.iterator collect {
-          case LOAD_LOCAL(l)  => l
-          case STORE_LOCAL(l) => l
-        }
-      }).toSet
-
-      if (hasCode) {
-        log("[checking locals of " + this + "]")
-        locals filterNot localsSet foreach { l =>
-          log("Local " + l + " is not declared in " + this)
-        }
-      }
-    }
 
     /** Merge together blocks that have a single successor which has a
      * single predecessor. Exception handlers are taken into account (they
@@ -294,9 +269,6 @@ trait Members {
     /** Starting PC for this local's visibility range. */
     var start: Int = _
 
-    /** Ending PC for this local's visibility range. */
-    var end: Int = _
-
     /** PC-based ranges for this local variable's visibility */
     var ranges: List[(Int, Int)] = Nil
 
diff --git a/src/compiler/scala/tools/nsc/backend/icode/Opcodes.scala b/src/compiler/scala/tools/nsc/backend/icode/Opcodes.scala
index 0e7c75de50..eaa742a1da 100644
--- a/src/compiler/scala/tools/nsc/backend/icode/Opcodes.scala
+++ b/src/compiler/scala/tools/nsc/backend/icode/Opcodes.scala
@@ -3,8 +3,6 @@
  * @author  Martin Odersky
  */
 
-
-
 package scala.tools.nsc
 package backend
 package icode
@@ -110,17 +108,11 @@ trait Opcodes { self: ICodes =>
     // Vlad: I wonder why we keep producedTypes around -- it looks like an useless thing to have
     def producedTypes: List[TypeKind] = Nil
 
-    /** This method returns the difference of size of the stack when the instruction is used */
-    def difference = produced-consumed
-
     /** The corresponding position in the source file */
     private var _pos: Position = NoPosition
 
     def pos: Position = _pos
 
-    /** Used by dead code elimination. */
-    var useful: Boolean = false
-
     def setPos(p: Position): this.type = {
       _pos = p
       this
@@ -132,13 +124,6 @@ trait Opcodes { self: ICodes =>
   }
 
   object opcodes {
-
-    def mayThrow(i: Instruction): Boolean = i match {
-      case LOAD_LOCAL(_) | STORE_LOCAL(_) | CONSTANT(_) | THIS(_) | CZJUMP(_, _, _, _)
-              | DROP(_) | DUP(_) | RETURN(_) | LOAD_EXCEPTION(_) | JUMP(_) | CJUMP(_, _, _, _) => false
-      case _ => true
-    }
-
     /** Loads "this" on top of the stack.
      * Stack: ...
      *    ->: ...:ref
@@ -714,8 +699,6 @@ trait Opcodes { self: ICodes =>
       /** Is this a static method call? */
       def isStatic: Boolean = false
 
-      def isSuper: Boolean = false
-
       /** Is this an instance method call? */
       def hasInstance: Boolean = true
 
@@ -749,7 +732,6 @@ trait Opcodes { self: ICodes =>
      *  On JVM, translated to `invokespecial`.
      */
     case class SuperCall(mix: Name) extends InvokeStyle {
-      override def isSuper = true
       override def toString(): String = { "super(" + mix + ")" }
     }
 
@@ -814,7 +796,7 @@ trait Opcodes { self: ICodes =>
 
     case class CIL_NEWOBJ(method: Symbol) extends Instruction {
       override def toString(): String = "CIL_NEWOBJ " + hostClass.fullName + method.fullName
-      var hostClass: Symbol = method.owner;
+      val hostClass: Symbol = method.owner;
       override def consumed = method.tpe.paramTypes.length
       override def consumedTypes = method.tpe.paramTypes map toTypeKind
       override def produced = 1
diff --git a/src/compiler/scala/tools/nsc/backend/icode/Primitives.scala b/src/compiler/scala/tools/nsc/backend/icode/Primitives.scala
index c8579041ba..351d99f51a 100644
--- a/src/compiler/scala/tools/nsc/backend/icode/Primitives.scala
+++ b/src/compiler/scala/tools/nsc/backend/icode/Primitives.scala
@@ -76,25 +76,12 @@ trait Primitives { self: ICodes =>
 
   /** Pretty printer for primitives */
   class PrimitivePrinter(out: PrintWriter) {
-
     def print(s: String): PrimitivePrinter = {
       out.print(s)
       this
     }
 
     def print(o: AnyRef): PrimitivePrinter = print(o.toString())
-
-    def printPrimitive(prim: Primitive) = prim match {
-      case Negation(kind) =>
-        print("!")
-
-      case Test(op, kind, zero) =>
-        print(op).print(kind)
-
-      case Comparison(op, kind) =>
-        print(op).print("(").print(kind)
-
-    }
   }
 
   /** This class represents a comparison operation. */
diff --git a/src/compiler/scala/tools/nsc/backend/icode/Repository.scala b/src/compiler/scala/tools/nsc/backend/icode/Repository.scala
index e73015c4da..e92e61c957 100644
--- a/src/compiler/scala/tools/nsc/backend/icode/Repository.scala
+++ b/src/compiler/scala/tools/nsc/backend/icode/Repository.scala
@@ -26,17 +26,6 @@ trait Repository {
   /** The icode of the given class, if available */
   def icode(sym: Symbol): Option[IClass] = (classes get sym) orElse (loaded get sym)
 
-  /** The icode of the given class. If not available, it loads
-   *  its bytecode.
-   */
-  def icode(sym: Symbol, force: Boolean): IClass =
-    icode(sym) getOrElse {
-      log("loading " + sym)
-      load(sym)
-      assert(available(sym))
-      loaded(sym)
-    }
-
   /** Load bytecode for given symbol. */
   def load(sym: Symbol): Boolean = {
     try {
diff --git a/src/compiler/scala/tools/nsc/backend/icode/TypeKinds.scala b/src/compiler/scala/tools/nsc/backend/icode/TypeKinds.scala
index f96dce9f1c..0990cfba6f 100644
--- a/src/compiler/scala/tools/nsc/backend/icode/TypeKinds.scala
+++ b/src/compiler/scala/tools/nsc/backend/icode/TypeKinds.scala
@@ -66,7 +66,6 @@ trait TypeKinds { self: ICodes =>
     def isValueType               = false
     def isBoxedType               = false
     final def isRefOrArrayType    = isReferenceType || isArrayType
-    final def isRefArrayOrBoxType = isRefOrArrayType || isBoxedType
     final def isNothingType       = this == NothingReference
     final def isNullType          = this == NullReference
     final def isInterfaceType     = this match {
@@ -114,8 +113,6 @@ trait TypeKinds { self: ICodes =>
     }
   }
 
-  var lubs0 = 0
-
   /**
    * The least upper bound of two typekinds. They have to be either
    * REFERENCE or ARRAY kinds.
diff --git a/src/compiler/scala/tools/nsc/backend/icode/TypeStacks.scala b/src/compiler/scala/tools/nsc/backend/icode/TypeStacks.scala
index c1bf4304ea..57d51dad49 100644
--- a/src/compiler/scala/tools/nsc/backend/icode/TypeStacks.scala
+++ b/src/compiler/scala/tools/nsc/backend/icode/TypeStacks.scala
@@ -20,8 +20,6 @@ trait TypeStacks {
    */
   type Rep = List[TypeKind]
 
-  object NoTypeStack extends TypeStack(Nil) { }
-
   class TypeStack(var types: Rep) {
     if (types.nonEmpty)
       checkerDebug("Created " + this)
@@ -69,14 +67,6 @@ trait TypeStacks {
 
     def apply(n: Int): TypeKind = types(n)
 
-    /**
-     * A TypeStack agrees with another one if they have the same
-     * length and each type kind agrees position-wise. Two
-     * types agree if one is a subtype of the other.
-     */
-    def agreesWith(other: TypeStack): Boolean =
-      (types corresponds other.types)((t1, t2) => t1 <:< t2 || t2 <:< t1)
-
     /* This method returns a String representation of the stack */
     override def toString() =
       if (types.isEmpty) "[]"
diff --git a/src/compiler/scala/tools/nsc/backend/icode/analysis/CopyPropagation.scala b/src/compiler/scala/tools/nsc/backend/icode/analysis/CopyPropagation.scala
index 4a5844531a..7f32b2b764 100644
--- a/src/compiler/scala/tools/nsc/backend/icode/analysis/CopyPropagation.scala
+++ b/src/compiler/scala/tools/nsc/backend/icode/analysis/CopyPropagation.scala
@@ -26,12 +26,8 @@ abstract class CopyPropagation {
   case object This extends Location
 
   /** Values that can be on the stack. */
-  abstract class Value {
-    def isRecord = false
-  }
-  case class Record(cls: Symbol, bindings: mutable.Map[Symbol, Value]) extends Value {
-    override def isRecord = true
-  }
+  abstract class Value { }
+  case class Record(cls: Symbol, bindings: mutable.Map[Symbol, Value]) extends Value { }
   /** The value of some location in memory. */
   case class Deref(l: Location) extends Value
 
@@ -91,16 +87,6 @@ abstract class CopyPropagation {
         loop(l) getOrElse Deref(LocalVar(l))
       }
 
-      /* Return the binding for the given field of the given record */
-      def getBinding(r: Record, f: Symbol): Value = {
-        assert(r.bindings contains f, "Record " + r + " does not contain a field " + f)
-
-        r.bindings(f) match {
-          case Deref(LocalVar(l)) => getBinding(l)
-          case target             => target
-        }
-      }
-
       /** Return a local which contains the same value as this field, if any.
        * If the field holds a reference to a local, the returned value is the
        * binding of that local.
diff --git a/src/compiler/scala/tools/nsc/backend/icode/analysis/DataFlowAnalysis.scala b/src/compiler/scala/tools/nsc/backend/icode/analysis/DataFlowAnalysis.scala
index 04c3eedbad..cc3a7eb876 100644
--- a/src/compiler/scala/tools/nsc/backend/icode/analysis/DataFlowAnalysis.scala
+++ b/src/compiler/scala/tools/nsc/backend/icode/analysis/DataFlowAnalysis.scala
@@ -34,15 +34,6 @@ trait DataFlowAnalysis[L <: SemiLattice] {
     f
   }
 
-  /** Reinitialize, but keep the old solutions. Should be used when reanalyzing the
-   *  same method, after some code transformation.
-   */
-  def reinit(f: => Unit): Unit = {
-    iterations = 0
-    worklist.clear; visited.clear;
-    f
-  }
-
   def run(): Unit
 
   /** Implements forward dataflow analysis: the transfer function is
@@ -82,10 +73,6 @@ trait DataFlowAnalysis[L <: SemiLattice] {
       sys.error("Could not find element " + e.getMessage)
   }
 
-  /** ...
-   *
-   *  @param f ...
-   */
   def backwardAnalysis(f: (P, lattice.Elem) => lattice.Elem): Unit =
     while (worklist.nonEmpty) {
       if (stat) iterations += 1
diff --git a/src/compiler/scala/tools/nsc/backend/icode/analysis/TypeFlowAnalysis.scala b/src/compiler/scala/tools/nsc/backend/icode/analysis/TypeFlowAnalysis.scala
index 15755f31ad..c9d295a350 100644
--- a/src/compiler/scala/tools/nsc/backend/icode/analysis/TypeFlowAnalysis.scala
+++ b/src/compiler/scala/tools/nsc/backend/icode/analysis/TypeFlowAnalysis.scala
@@ -268,36 +268,6 @@ abstract class TypeFlowAnalysis {
       out
     } // interpret
 
-
-    class SimulatedStack {
-      private var types: List[InferredType] = Nil
-      private var depth = 0
-
-      /** Remove and return the topmost element on the stack. If the
-       *  stack is empty, return a reference to a negative index on the
-       *  stack, meaning it refers to elements pushed by a predecessor block.
-       */
-      def pop: InferredType = types match {
-        case head :: rest =>
-          types = rest
-          head
-        case _ =>
-          depth -= 1
-          TypeOfStackPos(depth)
-      }
-
-      def pop2: (InferredType, InferredType) = {
-        (pop, pop)
-      }
-
-      def push(t: InferredType) {
-        depth += 1
-        types = types ::: List(t)
-      }
-
-      def push(k: TypeKind) { push(Const(k)) }
-    }
-
 	abstract class InferredType {
       /** Return the type kind pointed by this inferred type. */
       def getKind(in: lattice.Elem): icodes.TypeKind = this match {
@@ -737,10 +707,6 @@ abstract class TypeFlowAnalysis {
 
     private var lastStart = 0L
 
-    def reset() {
-      millis = 0L
-    }
-
     def start() {
       lastStart = System.currentTimeMillis
     }
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala
index 8bae80c760..1aa80d5c5b 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/GenASM.scala
@@ -455,7 +455,6 @@ abstract class GenASM extends SubComponent with BytecodeWriters {
   /** basic functionality for class file building */
   abstract class JBuilder(bytecodeWriter: BytecodeWriter) {
 
-    val EMPTY_JTYPE_ARRAY  = Array.empty[asm.Type]
     val EMPTY_STRING_ARRAY = Array.empty[String]
 
     val mdesc_arglessvoid = "()V"
@@ -523,7 +522,6 @@ abstract class GenASM extends SubComponent with BytecodeWriters {
     /** Specialized array conversion to prevent calling
      *  java.lang.reflect.Array.newInstance via TraversableOnce.toArray
      */
-    def mkArray(xs: Traversable[asm.Type]):  Array[asm.Type]  = { val a = new Array[asm.Type](xs.size); xs.copyToArray(a); a }
     def mkArray(xs: Traversable[String]):    Array[String]    = { val a = new Array[String](xs.size);   xs.copyToArray(a); a }
 
     // -----------------------------------------------------------------------------------------
@@ -1757,11 +1755,6 @@ abstract class GenASM extends SubComponent with BytecodeWriters {
 
       import asm.Opcodes;
 
-      def aconst(cst: AnyRef) {
-        if (cst == null) { jmethod.visitInsn(Opcodes.ACONST_NULL) }
-        else             { jmethod.visitLdcInsn(cst) }
-      }
-
       final def boolconst(b: Boolean) { iconst(if(b) 1 else 0) }
 
       def iconst(cst: Int) {
@@ -2924,15 +2917,8 @@ abstract class GenASM extends SubComponent with BytecodeWriters {
 
     ////////////////////// local vars ///////////////////////
 
-    // def sizeOf(sym: Symbol): Int = sizeOf(toTypeKind(sym.tpe))
-
     def sizeOf(k: TypeKind): Int = if(k.isWideType) 2 else 1
 
-    // def indexOf(m: IMethod, sym: Symbol): Int = {
-    //   val Some(local) = m lookupLocal sym
-    //   indexOf(local)
-    // }
-
     final def indexOf(local: Local): Int = {
       assert(local.index >= 0, "Invalid index for: " + local + "{" + local.## + "}: ")
       local.index
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala
index 31a4554d97..e1484d1f97 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala
@@ -182,15 +182,9 @@ abstract class GenJVM extends SubComponent with GenJVMUtil with GenAndroid with
     val StringBuilderType = new JObjectType(StringBuilderClassName)               // TODO use ASMType.getObjectType
     val toStringType      = new JMethodType(JAVA_LANG_STRING, JType.EMPTY_ARRAY)  // TODO use ASMType.getMethodType
     val arrayCloneType    = new JMethodType(JAVA_LANG_OBJECT, JType.EMPTY_ARRAY)
-    val MethodTypeType    = new JObjectType("java.dyn.MethodType")
-    val JavaLangClassType = new JObjectType("java.lang.Class")
-    val MethodHandleType  = new JObjectType("java.dyn.MethodHandle")
 
     // Scala attributes
     val BeanInfoAttr        = rootMirror.getRequiredClass("scala.beans.BeanInfo")
-    val BeanInfoSkipAttr    = rootMirror.getRequiredClass("scala.beans.BeanInfoSkip")
-    val BeanDisplayNameAttr = rootMirror.getRequiredClass("scala.beans.BeanDisplayName")
-    val BeanDescriptionAttr = rootMirror.getRequiredClass("scala.beans.BeanDescription")
 
     final val ExcludedForwarderFlags = {
       import Flags._
@@ -254,7 +248,6 @@ abstract class GenJVM extends SubComponent with GenJVMUtil with GenAndroid with
     var method: IMethod = _
     var jclass: JClass = _
     var jmethod: JMethod = _
-    // var jcode: JExtendedCode = _
 
     def isParcelableClass = isAndroidParcelableClass(clasz.symbol)
     def isRemoteClass = clasz.symbol hasAnnotation RemoteAttr
@@ -263,9 +256,6 @@ abstract class GenJVM extends SubComponent with GenJVMUtil with GenAndroid with
     }
 
     val fjbgContext = new FJBGContext(49, 0)
-
-    val emitSource = debugLevel >= 1
-    val emitLines  = debugLevel >= 2
     val emitVars   = debugLevel >= 3
 
     // bug had phase with wrong name; leaving enabled for brief pseudo deprecation
@@ -1835,15 +1825,8 @@ abstract class GenJVM extends SubComponent with GenJVMUtil with GenAndroid with
 
     ////////////////////// local vars ///////////////////////
 
-    def sizeOf(sym: Symbol): Int = sizeOf(toTypeKind(sym.tpe))
-
     def sizeOf(k: TypeKind): Int = if(k.isWideType) 2 else 1
 
-    def indexOf(m: IMethod, sym: Symbol): Int = {
-      val Some(local) = m lookupLocal sym
-      indexOf(local)
-    }
-
     def indexOf(local: Local): Int = {
       assert(local.index >= 0, "Invalid index for: " + local + "{" + local.## + "}: ")
       local.index
diff --git a/src/compiler/scala/tools/nsc/backend/msil/GenMSIL.scala b/src/compiler/scala/tools/nsc/backend/msil/GenMSIL.scala
index 2253ae6e15..2fb6550239 100644
--- a/src/compiler/scala/tools/nsc/backend/msil/GenMSIL.scala
+++ b/src/compiler/scala/tools/nsc/backend/msil/GenMSIL.scala
@@ -23,8 +23,6 @@ abstract class GenMSIL extends SubComponent {
   import icodes._
   import icodes.opcodes._
 
-  val x = loaders
-
   /** Create a new phase */
   override def newPhase(p: Phase) = new MsilPhase(p)
 
@@ -83,9 +81,6 @@ abstract class GenMSIL extends SubComponent {
                    SYMTAB_DEFAULT_CONSTR => SYMTAB_ATTRIBUTE_EMPTY_CONSTRUCTOR}
 
     val EXCEPTION = clrTypes.getType("System.Exception")
-    val MBYTE_ARRAY = clrTypes.mkArrayType(MBYTE)
-
-    val ICLONEABLE = clrTypes.getType("System.ICloneable")
     val MEMBERWISE_CLONE = MOBJECT.GetMethod("MemberwiseClone", MsilType.EmptyTypes)
 
     val MMONITOR       = clrTypes.getType("System.Threading.Monitor")
@@ -102,9 +97,6 @@ abstract class GenMSIL extends SubComponent {
 
     val INT_PTR = clrTypes.getType("System.IntPtr")
 
-    val JOBJECT = definitions.ObjectClass
-    val JSTRING = definitions.StringClass
-
     val SystemConvert = clrTypes.getType("System.Convert")
 
     val objParam = Array(MOBJECT)
@@ -622,7 +614,7 @@ abstract class GenMSIL extends SubComponent {
      *   - emit `Leave handlerReturnLabel` instead of the Return
      *   - emit code at the end: load the local and return its value
      */
-    var currentHandlers = new mutable.Stack[ExceptionHandler]
+    val currentHandlers = new mutable.Stack[ExceptionHandler]
     // The IMethod the Local/Label/Kind below belong to
     var handlerReturnMethod: IMethod = _
     // Stores the result when returning inside an exception block
diff --git a/src/compiler/scala/tools/nsc/backend/opt/ClosureElimination.scala b/src/compiler/scala/tools/nsc/backend/opt/ClosureElimination.scala
index 8d6de821bb..650775b259 100644
--- a/src/compiler/scala/tools/nsc/backend/opt/ClosureElimination.scala
+++ b/src/compiler/scala/tools/nsc/backend/opt/ClosureElimination.scala
@@ -187,10 +187,6 @@ abstract class ClosureElimination extends SubComponent {
       case Boxed(LocalVar(v)) =>
         LOAD_LOCAL(v)
     }
-
-    /** is field 'f' accessible from method 'm'? */
-    def accessible(f: Symbol, m: Symbol): Boolean =
-      f.isPublic || (f.isProtected && (f.enclosingPackageClass == m.enclosingPackageClass))
   } /* class ClosureElim */
 
 
diff --git a/src/compiler/scala/tools/nsc/backend/opt/Inliners.scala b/src/compiler/scala/tools/nsc/backend/opt/Inliners.scala
index 7d741aab60..ca1cfc8929 100644
--- a/src/compiler/scala/tools/nsc/backend/opt/Inliners.scala
+++ b/src/compiler/scala/tools/nsc/backend/opt/Inliners.scala
@@ -602,7 +602,6 @@ abstract class Inliners extends SubComponent {
       override def toString = m.toString
 
       val sym           = m.symbol
-      val name          = sym.name
       def owner         = sym.owner
       def paramTypes    = sym.info.paramTypes
       def minimumStack  = paramTypes.length + 1
@@ -618,13 +617,11 @@ abstract class Inliners extends SubComponent {
       def length        = blocks.length
       def openBlocks    = blocks filterNot (_.closed)
       def instructions  = m.code.instructions
-      // def linearized    = linearizer linearize m
 
       def isSmall         = (length <= SMALL_METHOD_SIZE) && blocks(0).length < 10
       def isLarge         = length > MAX_INLINE_SIZE
       def isRecursive     = m.recursive
       def hasHandlers     = handlers.nonEmpty || m.bytecodeHasEHs
-      def hasClosureParam = paramTypes exists (tp => isByNameParamType(tp) || isFunctionType(tp))
 
       def isSynchronized         = sym.hasFlag(Flags.SYNCHRONIZED)
       def hasNonFinalizerHandler = handlers exists {
@@ -732,7 +729,6 @@ abstract class Inliners extends SubComponent {
      */
     sealed abstract class InlineSafetyInfo {
       def isSafe   = false
-      def isUnsafe = !isSafe
     }
     case object NeverSafeToInline           extends InlineSafetyInfo
     case object InlineableAtThisCaller      extends InlineSafetyInfo { override def isSafe = true }