Expunged the .net backend.

It lives on in a branch born from this commit's parent.
It's abrupt; no attempt is made to offer a "smooth transition"
for the serious msil userbase, population zero. If anyone feels
very strongly that such a transition is necessary, I will be
happy to talk you into feeling differently.

30 files changed, 40 insertions, 4131 deletions

diff --git a/src/compiler/scala/tools/ant/Scalac.scala b/src/compiler/scala/tools/ant/Scalac.scala
index cf3b5f949b..e6671ba093 100644
--- a/src/compiler/scala/tools/ant/Scalac.scala
+++ b/src/compiler/scala/tools/ant/Scalac.scala
@@ -56,8 +56,6 @@ import scala.tools.nsc.reporters.{Reporter, ConsoleReporter}
  *  - `usejavacp`,
  *  - `failonerror`,
  *  - `scalacdebugging`,
- *  - `assemname`,
- *  - `assemrefs`.
  *
  *  It also takes the following parameters as nested elements:
  *  - `src` (for `srcdir`),
@@ -100,7 +98,7 @@ class Scalac extends ScalaMatchingTask with ScalacShared {
 
   /** Defines valid values for the `target` property. */
   object Target extends PermissibleValue {
-    val values = List("jvm-1.5", "jvm-1.5-fjbg", "jvm-1.5-asm", "jvm-1.6", "jvm-1.7", "msil")
+    val values = List("jvm-1.5", "jvm-1.5-fjbg", "jvm-1.5-asm", "jvm-1.6", "jvm-1.7")
   }
 
   /** Defines valid values for the `deprecation` and `unchecked` properties. */
@@ -170,11 +168,6 @@ class Scalac extends ScalaMatchingTask with ScalacShared {
   /** Indicates whether compilation errors will fail the build; defaults to true. */
   protected var failonerror: Boolean = true
 
-  // Name of the output assembly (only relevant with -target:msil)
-  protected var assemname: Option[String] = None
-  // List of assemblies referenced by the program (only relevant with -target:msil)
-  protected var assemrefs: Option[String] = None
-
   /** Prints out the files being compiled by the scalac ant task
    *  (not only the number of files). */
   protected var scalacDebugging: Boolean = false
@@ -421,9 +414,6 @@ class Scalac extends ScalaMatchingTask with ScalacShared {
    *  @param input The specified flag */
   def setScalacdebugging(input: Boolean) { scalacDebugging = input }
 
-  def setAssemname(input: String) { assemname = Some(input) }
-  def setAssemrefs(input: String) { assemrefs = Some(input) }
-
   /** Sets the `compilerarg` as a nested compilerarg Ant parameter.
    *  @return A compiler argument to be configured. */
   def createCompilerArg(): ImplementationSpecificArgument = {
@@ -616,9 +606,6 @@ class Scalac extends ScalaMatchingTask with ScalacShared {
     if (!unchecked.isEmpty) settings.unchecked.value = unchecked.get
     if (!usejavacp.isEmpty) settings.usejavacp.value = usejavacp.get
 
-    if (!assemname.isEmpty) settings.assemname.value = assemname.get
-    if (!assemrefs.isEmpty) settings.assemrefs.value = assemrefs.get
-
     val jvmargs = scalacCompilerArgs.getArgs filter (_ startsWith "-J")
     if (!jvmargs.isEmpty) settings.jvmargs.value = jvmargs.toList
     val defines = scalacCompilerArgs.getArgs filter (_ startsWith "-D")
diff --git a/src/compiler/scala/tools/ant/sabbus/ScalacFork.scala b/src/compiler/scala/tools/ant/sabbus/ScalacFork.scala
index 9cdf484080..d5545fe76a 100644
--- a/src/compiler/scala/tools/ant/sabbus/ScalacFork.scala
+++ b/src/compiler/scala/tools/ant/sabbus/ScalacFork.scala
@@ -80,7 +80,7 @@ class ScalacFork extends ScalaMatchingTask with ScalacShared with TaskArgs {
 
   private def createMapper() = {
     val mapper = new GlobPatternMapper()
-    val extension = if (isMSIL) "*.msil" else "*.class"
+    val extension = "*.class"
     mapper setTo extension
     mapper setFrom "*.scala"
 
@@ -104,9 +104,6 @@ class ScalacFork extends ScalaMatchingTask with ScalacShared with TaskArgs {
     sourcePath foreach (settings.sourcepath = _)
     settings.extraParams = extraArgsFlat
 
-    if (isMSIL)
-      settings.sourcedir = sourceDir
-
     val mapper = createMapper()
 
     val includedFiles: Array[File] =
diff --git a/src/compiler/scala/tools/ant/sabbus/TaskArgs.scala b/src/compiler/scala/tools/ant/sabbus/TaskArgs.scala
index 6bb1aaa306..b061bcf7fb 100644
--- a/src/compiler/scala/tools/ant/sabbus/TaskArgs.scala
+++ b/src/compiler/scala/tools/ant/sabbus/TaskArgs.scala
@@ -98,6 +98,4 @@ trait TaskArgs extends CompilationPathProperty {
     val parts = a.getParts
     if(parts eq null) Seq[String]() else parts.toSeq
   }
-
-  def isMSIL = compTarget exists (_ == "msil")
 }
diff --git a/src/compiler/scala/tools/nsc/Global.scala b/src/compiler/scala/tools/nsc/Global.scala
index 397e6c42d7..654dc92a9e 100644
--- a/src/compiler/scala/tools/nsc/Global.scala
+++ b/src/compiler/scala/tools/nsc/Global.scala
@@ -23,7 +23,7 @@ import ast.parser._
 import typechecker._
 import transform._
 import backend.icode.{ ICodes, GenICode, ICodeCheckers }
-import backend.{ ScalaPrimitives, Platform, MSILPlatform, JavaPlatform }
+import backend.{ ScalaPrimitives, Platform, JavaPlatform }
 import backend.jvm.{GenJVM, GenASM}
 import backend.opt.{ Inliners, InlineExceptionHandlers, ClosureElimination, DeadCodeElimination }
 import backend.icode.analysis._
@@ -77,8 +77,7 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
   type ThisPlatform = Platform { val global: Global.this.type }
 
   lazy val platform: ThisPlatform =
-    if (forMSIL) new { val global: Global.this.type = Global.this } with MSILPlatform
-    else new { val global: Global.this.type = Global.this } with JavaPlatform
+    new { val global: Global.this.type = Global.this } with JavaPlatform
 
   type PlatformClassPath = ClassPath[platform.BinaryRepr]
   type OptClassPath = Option[PlatformClassPath]
@@ -620,7 +619,7 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
   object terminal extends {
     val global: Global.this.type = Global.this
     val phaseName = "terminal"
-    val runsAfter = List("jvm", "msil")
+    val runsAfter = List("jvm")
     val runsRightAfter = None
   } with SubComponent {
     private var cache: Option[GlobalPhase] = None
@@ -1314,7 +1313,6 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
     val closelimPhase                = phaseNamed("closelim")
     val dcePhase                     = phaseNamed("dce")
     // val jvmPhase                     = phaseNamed("jvm")
-    // val msilPhase                    = phaseNamed("msil")
 
     def runIsAt(ph: Phase)   = globalPhase.id == ph.id
     def runIsAtOptimiz       = {
@@ -1675,14 +1673,6 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
       }
     })
   }
-  // In order to not outright break code which overrides onlyPresentation (like sbt 0.7.5.RC0)
-  // I restored and deprecated it.  That would be enough to avoid the compilation
-  // failure, but the override wouldn't accomplish anything.  So now forInteractive
-  // and forScaladoc default to onlyPresentation, which is the same as defaulting
-  // to false except in old code.  The downside is that this leaves us calling a
-  // deprecated method: but I see no simple way out, so I leave it for now.
-  // def forJVM           = settings.target.value startsWith "jvm"
-  override def forMSIL = settings.target.value startsWith "msil"
   def forInteractive   = false
   def forScaladoc      = false
   def createJavadoc    = false
diff --git a/src/compiler/scala/tools/nsc/Main.scala b/src/compiler/scala/tools/nsc/Main.scala
index 5a3ea56f67..a4b22b0e11 100644
--- a/src/compiler/scala/tools/nsc/Main.scala
+++ b/src/compiler/scala/tools/nsc/Main.scala
@@ -9,7 +9,6 @@ import java.io.File
 import File.pathSeparator
 import scala.tools.nsc.interactive.{ RefinedBuildManager, SimpleBuildManager }
 import scala.tools.nsc.io.AbstractFile
-import Properties.msilLibPath
 
 /** The main class for NSC, a compiler for the programming
  *  language Scala.
@@ -60,11 +59,7 @@ object Main extends Driver with EvalLoop {
       }
       false
     }
-    else {
-      if (settings.target.value == "msil")
-        msilLibPath foreach (x => settings.assemrefs.value += (pathSeparator + x))
-      true
-    }
+    else true
 
   override def newCompiler(): Global =
     if (settings.Yrangepos.value) new Global(settings, reporter) with interactive.RangePositions
diff --git a/src/compiler/scala/tools/nsc/Properties.scala b/src/compiler/scala/tools/nsc/Properties.scala
index 570d5572d6..feb4ded2f2 100644
--- a/src/compiler/scala/tools/nsc/Properties.scala
+++ b/src/compiler/scala/tools/nsc/Properties.scala
@@ -16,9 +16,6 @@ object Properties extends scala.util.PropertiesTrait {
   def residentPromptString = scalaPropOrElse("resident.prompt", "\nnsc> ")
   def shellPromptString    = scalaPropOrElse("shell.prompt", "\nscala> ")
 
-  // settings based on system properties
-  def msilLibPath          = propOrNone("msil.libpath")
-
   // derived values
   def isEmacsShell         = propOrEmpty("env.emacs") != ""
 }
diff --git a/src/compiler/scala/tools/nsc/ScalaDoc.scala b/src/compiler/scala/tools/nsc/ScalaDoc.scala
index ba434bc797..14b76b53b3 100644
--- a/src/compiler/scala/tools/nsc/ScalaDoc.scala
+++ b/src/compiler/scala/tools/nsc/ScalaDoc.scala
@@ -10,7 +10,6 @@ import java.io.File.pathSeparator
 import scala.tools.nsc.doc.DocFactory
 import scala.tools.nsc.reporters.ConsoleReporter
 import scala.reflect.internal.util.FakePos
-import Properties.msilLibPath
 
 /** The main class for scaladoc, a front-end for the Scala compiler
  *  that generates documentation from source files.
@@ -42,12 +41,8 @@ class ScalaDoc {
       reporter.warning(null, "Phases are restricted when using Scaladoc")
     else if (docSettings.help.value || !hasFiles)
       reporter.echo(command.usageMsg)
-    else try {
-      if (docSettings.target.value == "msil")
-        msilLibPath foreach (x => docSettings.assemrefs.value += (pathSeparator + x))
-
-      new DocFactory(reporter, docSettings) document command.files
-    }
+    else
+      try { new DocFactory(reporter, docSettings) document command.files }
     catch {
       case ex @ FatalError(msg) =>
         if (docSettings.debug.value) ex.printStackTrace()
diff --git a/src/compiler/scala/tools/nsc/backend/MSILPlatform.scala b/src/compiler/scala/tools/nsc/backend/MSILPlatform.scala
deleted file mode 100644
index 4493685b52..0000000000
--- a/src/compiler/scala/tools/nsc/backend/MSILPlatform.scala
+++ /dev/null
@@ -1,69 +0,0 @@
-/* NSC -- new Scala compiler
- * Copyright 2005-2013 LAMP/EPFL
- * @author  Paul Phillips
- */
-
-package scala.tools.nsc
-package backend
-
-import ch.epfl.lamp.compiler.{ msil => msillib }
-import util.{ ClassPath, MsilClassPath }
-import msil.GenMSIL
-import io.{ AbstractFile, MsilFile }
-
-trait MSILPlatform extends Platform {
-  import global._
-  import definitions.{ ComparatorClass, BoxedNumberClass, getMember }
-
-  type BinaryRepr = MsilFile
-
-  if (settings.verbose.value)
-    inform("[AssemRefs = " + settings.assemrefs.value + "]")
-
-  // phaseName = "msil"
-  object genMSIL extends {
-    val global: MSILPlatform.this.global.type = MSILPlatform.this.global
-    val runsAfter = List[String]("dce")
-    val runsRightAfter = None
-  } with GenMSIL
-
-  lazy val classPath = MsilClassPath.fromSettings(settings)
-  def rootLoader = new loaders.PackageLoader(classPath.asInstanceOf[ClassPath[platform.BinaryRepr]])
-    // See discussion in JavaPlatForm for why we need a cast here.
-
-  /** Update classpath with a substituted subentry */
-  def updateClassPath(subst: Map[ClassPath[BinaryRepr], ClassPath[BinaryRepr]]) =
-    throw new UnsupportedOperationException("classpath invalidations not supported on MSIL")
-
-  def platformPhases = List(
-    genMSIL   // generate .msil files
-  )
-
-  lazy val externalEquals = getMember(ComparatorClass.companionModule, nme.equals_)
-  def isMaybeBoxed(sym: Symbol) = sym isNonBottomSubClass BoxedNumberClass
-
-  def newClassLoader(bin: MsilFile): loaders.SymbolLoader =  new loaders.MsilFileLoader(bin)
-
-  /**
-   * Tells whether a class should be loaded and entered into the package
-   * scope. On .NET, this method returns `false` for all synthetic classes
-   * (anonymous classes, implementation classes, module classes), their
-   * symtab is encoded in the pickle of another class.
-   */
-  def doLoad(cls: ClassPath[BinaryRepr]#ClassRep): Boolean = {
-    if (cls.binary.isDefined) {
-      val typ = cls.binary.get.msilType
-      if (typ.IsDefined(loaders.clrTypes.SCALA_SYMTAB_ATTR, false)) {
-        val attrs = typ.GetCustomAttributes(loaders.clrTypes.SCALA_SYMTAB_ATTR, false)
-        assert(attrs.length == 1, attrs.length)
-        val a = attrs(0).asInstanceOf[msillib.Attribute]
-        // symtab_constr takes a byte array argument (the pickle), i.e. typ has a pickle.
-        // otherwise, symtab_default_constr was used, which marks typ as scala-synthetic.
-        a.getConstructor() == loaders.clrTypes.SYMTAB_CONSTR
-      } else true // always load non-scala types
-    } else true // always load source
-  }
-
-  def needCompile(bin: MsilFile, src: AbstractFile) =
-    false // always use compiled file on .net
-}
diff --git a/src/compiler/scala/tools/nsc/backend/icode/ExceptionHandlers.scala b/src/compiler/scala/tools/nsc/backend/icode/ExceptionHandlers.scala
index 7c2961778f..a872e9cd00 100644
--- a/src/compiler/scala/tools/nsc/backend/icode/ExceptionHandlers.scala
+++ b/src/compiler/scala/tools/nsc/backend/icode/ExceptionHandlers.scala
@@ -27,9 +27,6 @@ trait ExceptionHandlers {
     private var _startBlock: BasicBlock = _;
     var finalizer: Finalizer = _;
 
-    /** Needed for the MSIL backend. */
-    var resultKind: TypeKind = _;
-
     def setStartBlock(b: BasicBlock) = {
       _startBlock = b;
       b.exceptionHandlerStart = true
diff --git a/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala b/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala
index f07c331fb0..603e1209a5 100644
--- a/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala
+++ b/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala
@@ -164,10 +164,7 @@ abstract class GenICode extends SubComponent  {
     private def genStat(tree: Tree, ctx: Context): Context = tree match {
       case Assign(lhs @ Select(_, _), rhs) =>
         val isStatic = lhs.symbol.isStaticMember
-        var ctx1 = if (isStatic) ctx
-                   else if (forMSIL && msil_IsValuetypeInstField(lhs.symbol))
-                     msil_genLoadQualifierAddress(lhs, ctx)
-                   else genLoadQualifier(lhs, ctx)
+        var ctx1 = if (isStatic) ctx else genLoadQualifier(lhs, ctx)
 
         ctx1 = genLoad(rhs, ctx1, toTypeKind(lhs.symbol.info))
         ctx1.bb.emit(STORE_FIELD(lhs.symbol, isStatic), tree.pos)
@@ -301,9 +298,6 @@ abstract class GenICode extends SubComponent  {
       val Apply(fun, args) = tree
       val monitor = ctx.makeLocal(tree.pos, ObjectClass.tpe, "monitor")
       var monitorResult: Local = null
-
-      // if the synchronized block returns a result, store it in a local variable. just leaving
-      // it on the stack is not valid in MSIL (stack is cleaned when leaving try-blocks)
       val argTpe = args.head.tpe
       val hasResult = expectedType != UNIT
       if (hasResult)
@@ -462,131 +456,6 @@ abstract class GenICode extends SubComponent  {
     }
 
     /**
-     * forMSIL
-     */
-    private def msil_IsValuetypeInstMethod(msym: Symbol) = (
-      loaders.clrTypes.methods get msym exists (mMSIL =>
-        mMSIL.IsInstance && mMSIL.DeclaringType.IsValueType
-      )
-    )
-    private def msil_IsValuetypeInstField(fsym: Symbol) = (
-      loaders.clrTypes.fields get fsym exists (fMSIL =>
-        !fMSIL.IsStatic && fMSIL.DeclaringType.IsValueType
-      )
-    )
-
-    /**
-     * forMSIL: Adds a local var, the emitted code requires one more slot on the stack as on entry
-     */
-    private def msil_genLoadZeroOfNonEnumValuetype(ctx: Context, kind: TypeKind, pos: Position, leaveAddressOnStackInstead: Boolean) {
-      val REFERENCE(clssym) = kind
-      assert(loaders.clrTypes.isNonEnumValuetype(clssym), clssym)
-      val local = ctx.makeLocal(pos, clssym.tpe, "tmp")
-      ctx.method.addLocal(local)
-      ctx.bb.emit(CIL_LOAD_LOCAL_ADDRESS(local), pos)
-      ctx.bb.emit(CIL_INITOBJ(kind), pos)
-      val instr = if (leaveAddressOnStackInstead)
-                    CIL_LOAD_LOCAL_ADDRESS(local)
-                  else
-                    LOAD_LOCAL(local)
-      ctx.bb.emit(instr, pos)
-    }
-
-    /**
-     * forMSIL
-     */
-    private def msil_genLoadAddressOf(tree: Tree, ctx: Context, expectedType: TypeKind, butRawValueIsAlsoGoodEnough: Boolean): Context = {
-      var generatedType = expectedType
-      var addressTaken = false
-      debuglog("at line: " + (if (tree.pos.isDefined) tree.pos.line else tree.pos))
-
-      var resCtx: Context = tree match {
-
-        // emits CIL_LOAD_FIELD_ADDRESS
-        case Select(qualifier, selector) if (!tree.symbol.isModule) =>
-          addressTaken = true
-          val sym = tree.symbol
-          generatedType = toTypeKind(sym.info)
-
-          if (sym.isStaticMember) {
-            ctx.bb.emit(CIL_LOAD_FIELD_ADDRESS(sym, true), tree.pos)
-            ctx
-          } else {
-            val ctx1 = genLoadQualifier(tree, ctx)
-            ctx1.bb.emit(CIL_LOAD_FIELD_ADDRESS(sym, false), tree.pos)
-            ctx1
-          }
-
-        // emits CIL_LOAD_LOCAL_ADDRESS
-        case Ident(name) if (!tree.symbol.isPackage && !tree.symbol.isModule)=>
-          addressTaken = true
-          val sym = tree.symbol
-          try {
-            val Some(l) = ctx.method.lookupLocal(sym)
-            ctx.bb.emit(CIL_LOAD_LOCAL_ADDRESS(l), tree.pos)
-            generatedType = l.kind // actually, should be "V&" but the callsite is aware of this
-          } catch {
-            case ex: MatchError =>
-              abort("symbol " + sym + " does not exist in " + ctx.method)
-          }
-          ctx
-
-        // emits CIL_LOAD_ARRAY_ITEM_ADDRESS
-        case Apply(fun, args) =>
-          if (isPrimitive(fun.symbol)) {
-            val sym = tree.symbol
-            val Select(receiver, _) = fun
-            val code = scalaPrimitives.getPrimitive(sym, receiver.tpe)
-
-            if (isArrayOp(code)) {
-              val arrayObj = receiver
-              val k = toTypeKind(arrayObj.tpe)
-              val ARRAY(elementType) = k
-              if (scalaPrimitives.isArrayGet(code)) {
-                var ctx1 = genLoad(arrayObj, ctx, k)
-                // load argument on stack
-                debugassert(args.length == 1, "Too many arguments for array get operation: " + tree)
-                ctx1 = genLoad(args.head, ctx1, INT)
-                generatedType = elementType // actually "managed pointer to element type" but the callsite is aware of this
-                ctx1.bb.emit(CIL_LOAD_ARRAY_ITEM_ADDRESS(elementType), tree.pos)
-                addressTaken = true
-                ctx1
-              } else null
-            } else null
-          } else null
-
-        case This(qual) =>
-          /* TODO: this case handler is a placeholder for the time when Level 2 support for valuetypes is in place,
-             in particular when invoking other methods on this where this is a valuetype value (boxed or not).
-             As receiver, a managed pointer is expected, and a plain ldarg.0 achieves just that. */
-          addressTaken = true
-          genLoad(tree, ctx, expectedType)
-
-        case _ =>
-          null /* A method returning ByRef won't pass peverify, so I guess this case handler is dead code.
-                  Even if it's not, the code below to handler !addressTaken below. */
-      }
-
-      if (!addressTaken) {
-        resCtx = genLoad(tree, ctx, expectedType)
-        if (!butRawValueIsAlsoGoodEnough) {
-          // raw value on stack (must be an intermediate result, e.g. returned by method call), take address
-          addressTaken = true
-          val boxType = expectedType // toTypeKind(expectedType /* TODO FIXME */)
-          resCtx.bb.emit(BOX(boxType), tree.pos)
-          resCtx.bb.emit(CIL_UNBOX(boxType), tree.pos)
-        }
-      }
-
-      // emit conversion
-      if (generatedType != expectedType)
-        abort("Unexpected tree in msil_genLoadAddressOf: " + tree + " at: " + tree.pos)
-
-      resCtx
-    }
-
-
-    /**
      * Generate code for trees that produce values on the stack
      *
      * @param tree The tree to be translated
@@ -808,31 +677,15 @@ abstract class GenICode extends SubComponent  {
                 debugassert(ctor.owner == cls,
                             "Symbol " + ctor.owner.fullName + " is different than " + tpt)
 
-                val ctx2 = if (forMSIL && loaders.clrTypes.isNonEnumValuetype(cls)) {
-                  /* parameterful constructors are the only possible custom constructors,
-                     a default constructor can't be defined for valuetypes, CLR dixit */
-                  val isDefaultConstructor = args.isEmpty
-                  if (isDefaultConstructor) {
-                    msil_genLoadZeroOfNonEnumValuetype(ctx, rt, tree.pos, leaveAddressOnStackInstead = false)
-                    ctx
-                  } else {
-                    val ctx1 = genLoadArguments(args, ctor.info.paramTypes, ctx)
-                    ctx1.bb.emit(CIL_NEWOBJ(ctor), tree.pos)
-                    ctx1
-                  }
-                } else {
-                  val nw = NEW(rt)
-                  ctx.bb.emit(nw, tree.pos)
-                  ctx.bb.emit(DUP(generatedType))
-                  val ctx1 = genLoadArguments(args, ctor.info.paramTypes, ctx)
-
-                  val init = CALL_METHOD(ctor, Static(true))
-                  nw.init = init
-                  ctx1.bb.emit(init, tree.pos)
-                  ctx1
-                }
-                ctx2
+                val nw = NEW(rt)
+                ctx.bb.emit(nw, tree.pos)
+                ctx.bb.emit(DUP(generatedType))
+                val ctx1 = genLoadArguments(args, ctor.info.paramTypes, ctx)
 
+                val init = CALL_METHOD(ctor, Static(true))
+                nw.init = init
+                ctx1.bb.emit(init, tree.pos)
+                ctx1
               case _ =>
                 abort("Cannot instantiate " + tpt + " of kind: " + generatedType)
             }
@@ -866,12 +719,6 @@ abstract class GenICode extends SubComponent  {
           ctx1.bb.emit(UNBOX(boxType), expr.pos)
           ctx1
 
-        case Apply(fun @ _, List(expr)) if (forMSIL && loaders.clrTypes.isAddressOf(fun.symbol)) =>
-          debuglog("ADDRESSOF : " + fun.symbol.fullName);
-          val ctx1 = msil_genLoadAddressOf(expr, ctx, toTypeKind(expr.tpe), butRawValueIsAlsoGoodEnough = false)
-          generatedType = toTypeKind(fun.symbol.tpe.resultType)
-          ctx1
-
         case app @ Apply(fun, args) =>
           def genLoadApply6 = {
             val sym = fun.symbol
@@ -913,14 +760,7 @@ abstract class GenICode extends SubComponent  {
                 else
                   Dynamic
 
-              var ctx1 =
-                if (invokeStyle.hasInstance) {
-                  if (forMSIL && !(invokeStyle.isInstanceOf[SuperCall]) && msil_IsValuetypeInstMethod(sym))
-                    msil_genLoadQualifierAddress(fun, ctx)
-                  else
-                    genLoadQualifier(fun, ctx)
-                } else ctx
-
+              var ctx1 = if (invokeStyle.hasInstance) genLoadQualifier(fun, ctx) else ctx
               ctx1 = genLoadArguments(args, sym.info.paramTypes, ctx1)
               val cm = CALL_METHOD(sym, invokeStyle)
 
@@ -956,7 +796,6 @@ abstract class GenICode extends SubComponent  {
           genLoadApply6
 
         case ApplyDynamic(qual, args) =>
-          assert(!forMSIL, tree)
           // TODO - this is where we'd catch dynamic applies for invokedynamic.
           sys.error("No invokedynamic support yet.")
           // val ctx1 = genLoad(qual, ctx, ObjectReference)
@@ -1189,15 +1028,6 @@ abstract class GenICode extends SubComponent  {
           abort("Unknown qualifier " + tree)
       }
 
-    /** forMSIL */
-    private def msil_genLoadQualifierAddress(tree: Tree, ctx: Context): Context =
-      tree match {
-        case Select(qualifier, _) =>
-          msil_genLoadAddressOf(qualifier, ctx, toTypeKind(qualifier.tpe), butRawValueIsAlsoGoodEnough = false)
-        case _ =>
-          abort("Unknown qualifier " + tree)
-      }
-
     /**
      * Generate code that loads args into label parameters.
      */
@@ -1385,7 +1215,7 @@ abstract class GenICode extends SubComponent  {
     def genStringConcat(tree: Tree, ctx: Context): Context = {
       liftStringConcat(tree) match {
         // Optimization for expressions of the form "" + x.  We can avoid the StringBuilder.
-        case List(Literal(Constant("")), arg) if !forMSIL =>
+        case List(Literal(Constant("")), arg) =>
           debuglog("Rewriting \"\" + x as String.valueOf(x) for: " + arg)
           val ctx1 = genLoad(arg, ctx, ObjectReference)
           ctx1.bb.emit(CALL_METHOD(String_valueOf, Static(false)), arg.pos)
@@ -1988,10 +1818,9 @@ abstract class GenICode extends SubComponent  {
        * 'covered' by this exception handler (in addition to the
        * previously active handlers).
        */
-      private def newExceptionHandler(cls: Symbol, resultKind: TypeKind, pos: Position): ExceptionHandler = {
+      private def newExceptionHandler(cls: Symbol, pos: Position): ExceptionHandler = {
         handlerCount += 1
         val exh = new ExceptionHandler(method, newTermNameCached("" + handlerCount), cls, pos)
-        exh.resultKind = resultKind
         method.addHandler(exh)
         handlers = exh :: handlers
         debuglog("added handler: " + exh);
@@ -2051,7 +1880,7 @@ abstract class GenICode extends SubComponent  {
       def Try(body: Context => Context,
               handlers: List[(Symbol, TypeKind, Context => Context)],
               finalizer: Tree,
-              tree: Tree) = if (forMSIL) TryMsil(body, handlers, finalizer, tree) else {
+              tree: Tree) = {
 
         val outerCtx = this.dup       // context for generating exception handlers, covered by finalizer
         val finalizerCtx = this.dup   // context for generating finalizer handler
@@ -2083,7 +1912,7 @@ abstract class GenICode extends SubComponent  {
 
 
         if (finalizer != EmptyTree) {
-          val exh = outerCtx.newExceptionHandler(NoSymbol, toTypeKind(finalizer.tpe), finalizer.pos) // finalizer covers exception handlers
+          val exh = outerCtx.newExceptionHandler(NoSymbol, finalizer.pos) // finalizer covers exception handlers
           this.addActiveHandler(exh)  // .. and body aswell
           val ctx = finalizerCtx.enterExceptionHandler(exh)
           val exception = ctx.makeLocal(finalizer.pos, ThrowableClass.tpe, "exc")
@@ -2098,7 +1927,7 @@ abstract class GenICode extends SubComponent  {
         }
 
         for ((sym, kind, handler) <- handlers) {
-          val exh = this.newExceptionHandler(sym, kind, tree.pos)
+          val exh = this.newExceptionHandler(sym, tree.pos)
           var ctx1 = outerCtx.enterExceptionHandler(exh)
           ctx1.addFinalizer(finalizer, finalizerCtx)
           loadException(ctx1, exh, tree.pos)
@@ -2122,67 +1951,6 @@ abstract class GenICode extends SubComponent  {
 
         afterCtx
       }
-
-
-      /** try-catch-finally blocks are actually simpler to emit in MSIL, because there
-       *  is support for `finally` in bytecode.
-       *
-       *  A
-       *    try { .. } catch { .. } finally { .. }
-       *  block is de-sugared into
-       *    try { try { ..} catch { .. } } finally { .. }
-       *
-       *  In ICode `finally` block is represented exactly the same as an exception handler,
-       *  but with `NoSymbol` as the exception class. The covered blocks are all blocks of
-       *  the `try { .. } catch { .. }`.
-       *
-       *  Also, TryMsil does not enter any Finalizers into the `cleanups`, because the
-       *  CLI takes care of running the finalizer when seeing a `leave` statement inside
-       *  a try / catch.
-       */
-      def TryMsil(body: Context => Context,
-                  handlers: List[(Symbol, TypeKind, (Context => Context))],
-                  finalizer: Tree,
-                  tree: Tree) = {
-
-        val outerCtx = this.dup       // context for generating exception handlers, covered by finalizer
-        val finalizerCtx = this.dup   // context for generating finalizer handler
-        val afterCtx = outerCtx.newBlock
-
-        if (finalizer != EmptyTree) {
-          // finalizer is covers try and all catch blocks, i.e.
-          //   try { try { .. } catch { ..} } finally { .. }
-          val exh = outerCtx.newExceptionHandler(NoSymbol, UNIT, tree.pos)
-          this.addActiveHandler(exh)
-          val ctx = finalizerCtx.enterExceptionHandler(exh)
-          loadException(ctx, exh, tree.pos)
-          val ctx1 = genLoad(finalizer, ctx, UNIT)
-          // need jump for the ICode to be valid. MSIL backend will emit `Endfinally` instead.
-          ctx1.bb.closeWith(JUMP(afterCtx.bb))
-          finalizerCtx.endHandler()
-        }
-
-        for (handler <- handlers) {
-          val exh = this.newExceptionHandler(handler._1, handler._2, tree.pos)
-          var ctx1 = outerCtx.enterExceptionHandler(exh)
-          loadException(ctx1, exh, tree.pos)
-          ctx1 = handler._3(ctx1)
-          // msil backend will emit `Leave` to jump out of a handler
-          ctx1.bb.closeWith(JUMP(afterCtx.bb))
-          outerCtx.endHandler()
-        }
-
-        val bodyCtx = this.newBlock
-
-        val finalCtx = body(bodyCtx)
-
-        outerCtx.bb.closeWith(JUMP(bodyCtx.bb))
-
-        // msil backend will emit `Leave` to jump out of a try-block
-        finalCtx.bb.closeWith(JUMP(afterCtx.bb))
-
-        afterCtx
-      }
     }
   }
 
diff --git a/src/compiler/scala/tools/nsc/backend/icode/Linearizers.scala b/src/compiler/scala/tools/nsc/backend/icode/Linearizers.scala
index b8a98955c9..80477f0c6e 100644
--- a/src/compiler/scala/tools/nsc/backend/icode/Linearizers.scala
+++ b/src/compiler/scala/tools/nsc/backend/icode/Linearizers.scala
@@ -197,142 +197,4 @@ trait Linearizers {
     def linearize(m: IMethod): List[BasicBlock] = m.blocks
     def linearizeAt(m: IMethod, start: BasicBlock): List[BasicBlock] = sys.error("not implemented")
   }
-
-  /** The MSIL linearizer is used only for methods with at least one exception handler.
-   *  It makes sure that all the blocks belonging to a `try`, `catch` or `finally` block
-   *  are emitted in an order that allows the lexical nesting of try-catch-finally, just
-   *  like in the source code.
-   */
-  class MSILLinearizer extends Linearizer {
-    /** The MSIL linearizer first calls a NormalLInearizer. This is because the ILGenerator checks
-     *  the stack size before emitting instructions. For instance, to emit a `store`, there needs
-     *  to be some value on the stack. This can blow up in situations like this:
-     *       ...
-     *       jump 3
-     *    4: store_local 0
-     *       jump 5
-     *    3: load_value
-     *       jump 4
-     *    5: ...
-     *  here, 3 must be scheduled first.
-     *
-     *  The NormalLinearizer also removes dead blocks (blocks without predecessor). This is important
-     *  in the following example:
-     *     try { throw new Exception }
-     *     catch { case e => throw e }
-     *  which adds a dead block containing just a "throw" (which, again, would blow up code generation
-     *  because of the stack size; there's no value on the stack when emitting that `throw`)
-     */
-    val normalLinearizer = new NormalLinearizer()
-
-    def linearize(m: IMethod): List[BasicBlock] = {
-
-      val handlersByCovered = m.exh.groupBy(_.covered)
-
-      // number of basic blocks covered by the entire try-catch expression
-      def size(covered: scala.collection.immutable.Set[BasicBlock]) = {
-        val hs = handlersByCovered(covered)
-        covered.size + (hs :\ 0)((h, s) => h.blocks.length + s)
-      }
-
-      val tryBlocks = handlersByCovered.keys.toList sortBy size
-      var result    = normalLinearizer.linearize(m)
-      val frozen    = mutable.HashSet[BasicBlock](result.head)
-
-      for (tryBlock <- tryBlocks) {
-        result = groupBlocks(m, result, handlersByCovered(tryBlock), frozen)
-      }
-      result
-    }
-
-    /** @param handlers a list of handlers covering the same blocks (same try, multiple catches)
-     *  @param frozen blocks can't be moved (fist block of a method, blocks directly following a try-catch)
-     */
-    def groupBlocks(method: IMethod, blocks: List[BasicBlock], handlers: List[ExceptionHandler], frozen: mutable.HashSet[BasicBlock]) = {
-      assert(blocks.head == method.startBlock, method)
-
-      // blocks before the try, and blocks for the try
-      val beforeAndTry = new ListBuffer[BasicBlock]()
-      // blocks for the handlers
-      val catches = handlers map (_ => new ListBuffer[BasicBlock]())
-      // blocks to be put at the end
-      val after = new ListBuffer[BasicBlock]()
-
-      var beforeTry = true
-      val head = handlers.head
-
-      for (b <- blocks) {
-        if (head covers b) {
-          beforeTry = false
-          beforeAndTry += b
-        } else {
-          val handlerIndex = handlers.indexWhere(_.blocks.contains(b))
-          if (handlerIndex >= 0) {
-            catches(handlerIndex) += b
-          } else if (beforeTry) {
-            beforeAndTry += b
-          } else {
-            after += b
-          }
-        }
-      }
-
-      // reorder the blocks in "catches" so that the "firstBlock" is actually first
-      (catches, handlers).zipped foreach { (lb, handler) =>
-        lb -= handler.startBlock
-        handler.startBlock +=: lb
-      }
-
-      // The first block emitted after a try-catch must be the one that the try / catch
-      // blocks jump to (because in msil, these jumps cannot be emitted manually)
-      var firstAfter: Option[BasicBlock] = None
-
-      // Find the (hopefully) unique successor, look at the try and all catch blocks
-      var blks = head.covered.toList :: handlers.map(_.blocks)
-      while (firstAfter.isEmpty && !blks.isEmpty) {
-        val b = blks.head
-        blks = blks.tail
-
-        val leaving = leavingBlocks(b)
-        // no leaving blocks when the try or catch ends with THROW or RET
-        if (!leaving.isEmpty) {
-          assert(leaving.size <= 1, leaving)
-          firstAfter = Some(leaving.head)
-        }
-      }
-      if (firstAfter.isDefined) {
-        val b = firstAfter.get
-        if (frozen(b)) {
-          assert(after contains b, b +", "+ method)
-        } else {
-          frozen += b
-          if (beforeAndTry contains b) {
-            beforeAndTry -= b
-          } else {
-            assert(after contains b, after)
-            after -= b
-          }
-          b +=: after
-        }
-      }
-
-      for (lb <- catches) { beforeAndTry ++= lb }
-      beforeAndTry ++= after
-      beforeAndTry.toList
-    }
-
-    /** Returns all direct successors of `blocks` wich are not part
-     *  that list, i.e. successors outside the `blocks` list.
-     */
-    private def leavingBlocks(blocks: List[BasicBlock]) = {
-      val res = new mutable.HashSet[BasicBlock]()
-      for (b <- blocks; s <- b.directSuccessors; if (!blocks.contains(s)))
-        res += s
-      res
-    }
-
-    def linearizeAt(m: IMethod, start: BasicBlock): List[BasicBlock] = {
-      sys.error("not implemented")
-    }
-  }
 }
diff --git a/src/compiler/scala/tools/nsc/backend/icode/Opcodes.scala b/src/compiler/scala/tools/nsc/backend/icode/Opcodes.scala
index eaa742a1da..137e2b556f 100644
--- a/src/compiler/scala/tools/nsc/backend/icode/Opcodes.scala
+++ b/src/compiler/scala/tools/nsc/backend/icode/Opcodes.scala
@@ -734,74 +734,5 @@ trait Opcodes { self: ICodes =>
     case class SuperCall(mix: Name) extends InvokeStyle {
       override def toString(): String = { "super(" + mix + ")" }
     }
-
-
-    // CLR backend
-
-    case class CIL_LOAD_LOCAL_ADDRESS(local: Local) extends Instruction {
-      /** Returns a string representation of this instruction */
-      override def toString(): String = "CIL_LOAD_LOCAL_ADDRESS "+local  //+isArgument?" (argument)":"";
-
-      override def consumed = 0
-      override def produced = 1
-
-      override def producedTypes = msil_mgdptr(local.kind) :: Nil
-
-      override def category = localsCat
-    }
-
-    case class CIL_LOAD_FIELD_ADDRESS(field: Symbol, isStatic: Boolean) extends Instruction {
-      /** Returns a string representation of this instruction */
-      override def toString(): String =
-        "CIL_LOAD_FIELD_ADDRESS " + (if (isStatic) field.fullName else field.toString)
-
-      override def consumed = if (isStatic) 0 else 1
-      override def produced = 1
-
-      override def consumedTypes = if (isStatic) Nil else REFERENCE(field.owner) :: Nil;
-      override def producedTypes = msil_mgdptr(REFERENCE(field.owner)) :: Nil;
-
-      override def category = fldsCat
-    }
-
-    case class CIL_LOAD_ARRAY_ITEM_ADDRESS(kind: TypeKind) extends Instruction {
-      /** Returns a string representation of this instruction */
-      override def toString(): String = "CIL_LOAD_ARRAY_ITEM_ADDRESS (" + kind + ")"
-
-      override def consumed = 2
-      override def produced = 1
-
-      override def consumedTypes = ARRAY(kind) :: INT :: Nil
-      override def producedTypes = msil_mgdptr(kind) :: Nil
-
-      override def category = arraysCat
-    }
-
-    case class CIL_UNBOX(valueType: TypeKind) extends Instruction {
-      override def toString(): String = "CIL_UNBOX " + valueType
-      override def consumed = 1
-      override def consumedTypes = ObjectReferenceList // actually consumes a 'boxed valueType'
-      override def produced = 1
-      override def producedTypes = msil_mgdptr(valueType) :: Nil
-      override def category = objsCat
-    }
-
-    case class CIL_INITOBJ(valueType: TypeKind) extends Instruction {
-      override def toString(): String = "CIL_INITOBJ " + valueType
-      override def consumed = 1
-      override def consumedTypes = ObjectReferenceList // actually consumes a managed pointer
-      override def produced = 0
-      override def category = objsCat
-    }
-
-    case class CIL_NEWOBJ(method: Symbol) extends Instruction {
-      override def toString(): String = "CIL_NEWOBJ " + hostClass.fullName + method.fullName
-      val hostClass: Symbol = method.owner;
-      override def consumed = method.tpe.paramTypes.length
-      override def consumedTypes = method.tpe.paramTypes map toTypeKind
-      override def produced = 1
-      override def producedTypes = toTypeKind(method.tpe.resultType) :: Nil
-      override def category = objsCat
-    }
   }
 }
diff --git a/src/compiler/scala/tools/nsc/backend/icode/TypeKinds.scala b/src/compiler/scala/tools/nsc/backend/icode/TypeKinds.scala
index 0990cfba6f..84f5fe2678 100644
--- a/src/compiler/scala/tools/nsc/backend/icode/TypeKinds.scala
+++ b/src/compiler/scala/tools/nsc/backend/icode/TypeKinds.scala
@@ -427,11 +427,4 @@ trait TypeKinds { self: ICodes =>
     primitiveTypeMap.getOrElse(sym, newReference(sym))
   private def primitiveOrClassType(sym: Symbol, targs: List[Type]) =
     primitiveTypeMap.getOrElse(sym, arrayOrClassType(sym, targs))
-
-  def msil_mgdptr(tk: TypeKind): TypeKind = (tk: @unchecked) match {
-    case REFERENCE(cls)  => REFERENCE(loaders.clrTypes.mdgptrcls4clssym(cls))
-    // TODO have ready class-symbols for the by-ref versions of built-in valuetypes
-    case _ => abort("cannot obtain a managed pointer for " + tk)
-  }
-
 }
diff --git a/src/compiler/scala/tools/nsc/backend/msil/GenMSIL.scala b/src/compiler/scala/tools/nsc/backend/msil/GenMSIL.scala
deleted file mode 100644
index 2fb6550239..0000000000
--- a/src/compiler/scala/tools/nsc/backend/msil/GenMSIL.scala
+++ /dev/null
@@ -1,2244 +0,0 @@
-/* NSC -- new scala compiler
- * Copyright 2005-2013 LAMP/EPFL
- * @author Nikolay Mihaylov
- */
-
-
-package scala.tools.nsc
-package backend.msil
-
-import java.io.{File, IOException}
-import scala.collection.{ mutable, immutable }
-import scala.tools.nsc.symtab._
-
-import ch.epfl.lamp.compiler.msil.{Type => MsilType, _}
-import ch.epfl.lamp.compiler.msil.emit._
-import ch.epfl.lamp.compiler.msil.util.PECustomMod
-import scala.language.postfixOps
-
-abstract class GenMSIL extends SubComponent {
-  import global._
-  import loaders.clrTypes
-  import clrTypes.{types, constructors, methods, fields}
-  import icodes._
-  import icodes.opcodes._
-
-  /** Create a new phase */
-  override def newPhase(p: Phase) = new MsilPhase(p)
-
-  val phaseName = "msil"
-  /** MSIL code generation phase
-   */
-  class MsilPhase(prev: Phase) extends GlobalPhase(prev) {
-    def name = phaseName
-    override def newFlags = phaseNewFlags
-
-    override def erasedTypes = true
-
-    override def run() {
-      if (settings.debug.value) inform("[running phase " + name + " on icode]")
-
-      val codeGenerator = new BytecodeGenerator
-
-      //classes is ICodes.classes, a HashMap[Symbol, IClass]
-      classes.values foreach codeGenerator.findEntryPoint
-      if( settings.Xshowcls.isSetByUser && (codeGenerator.entryPoint == null) ) { // TODO introduce dedicated setting instead
-        val entryclass = settings.Xshowcls.value.toString
-        warning("Couldn't find entry class " + entryclass)
-      }
-
-      codeGenerator.initAssembly
-
-      val classesSorted = classes.values.toList.sortBy(c => c.symbol.id) // simplifies comparing cross-compiler vs. .exe output
-      classesSorted foreach codeGenerator.createTypeBuilder
-      classesSorted foreach codeGenerator.createClassMembers
-
-      try {
-        classesSorted foreach codeGenerator.genClass
-      } finally {
-        codeGenerator.writeAssembly
-      }
-    }
-
-    override def apply(unit: CompilationUnit) {
-      abort("MSIL works on icode classes, not on compilation units!")
-    }
-  }
-
-  /**
-   * MSIL bytecode generator.
-   *
-   */
-  class BytecodeGenerator {
-
-    val MODULE_INSTANCE_NAME = "MODULE$"
-
-    import clrTypes.{VOID => MVOID, BOOLEAN => MBOOL, BYTE => MBYTE, SHORT => MSHORT,
-                   CHAR => MCHAR, INT => MINT, LONG => MLONG, FLOAT => MFLOAT,
-                   DOUBLE => MDOUBLE, OBJECT => MOBJECT, STRING => MSTRING,
-                   STRING_ARRAY => MSTRING_ARRAY,
-                   SYMTAB_CONSTR => SYMTAB_ATTRIBUTE_CONSTRUCTOR,
-                   SYMTAB_DEFAULT_CONSTR => SYMTAB_ATTRIBUTE_EMPTY_CONSTRUCTOR}
-
-    val EXCEPTION = clrTypes.getType("System.Exception")
-    val MEMBERWISE_CLONE = MOBJECT.GetMethod("MemberwiseClone", MsilType.EmptyTypes)
-
-    val MMONITOR       = clrTypes.getType("System.Threading.Monitor")
-    val MMONITOR_ENTER = MMONITOR.GetMethod("Enter", Array(MOBJECT))
-    val MMONITOR_EXIT  = MMONITOR.GetMethod("Exit", Array(MOBJECT))
-
-    val MSTRING_BUILDER = clrTypes.getType("System.Text.StringBuilder")
-    val MSTRING_BUILDER_CONSTR = MSTRING_BUILDER.GetConstructor(MsilType.EmptyTypes)
-    val MSTRING_BUILDER_TOSTRING = MSTRING_BUILDER.GetMethod("ToString",
-                                                             MsilType.EmptyTypes)
-
-    val TYPE_FROM_HANDLE =
-      clrTypes.getType("System.Type").GetMethod("GetTypeFromHandle", Array(clrTypes.getType("System.RuntimeTypeHandle")))
-
-    val INT_PTR = clrTypes.getType("System.IntPtr")
-
-    val SystemConvert = clrTypes.getType("System.Convert")
-
-    val objParam = Array(MOBJECT)
-
-    val toBool:   MethodInfo = SystemConvert.GetMethod("ToBoolean", objParam) // see comment in emitUnbox
-    val toSByte:  MethodInfo = SystemConvert.GetMethod("ToSByte",   objParam)
-    val toShort:  MethodInfo = SystemConvert.GetMethod("ToInt16",   objParam)
-    val toChar:   MethodInfo = SystemConvert.GetMethod("ToChar",    objParam)
-    val toInt:    MethodInfo = SystemConvert.GetMethod("ToInt32",   objParam)
-    val toLong:   MethodInfo = SystemConvert.GetMethod("ToInt64",   objParam)
-    val toFloat:  MethodInfo = SystemConvert.GetMethod("ToSingle",  objParam)
-    val toDouble: MethodInfo = SystemConvert.GetMethod("ToDouble",  objParam)
-
-    //val boxedUnit: FieldInfo = msilType(definitions.BoxedUnitModule.info).GetField("UNIT")
-    val boxedUnit: FieldInfo = fields(definitions.BoxedUnit_UNIT)
-
-    // Scala attributes
-    // symtab.Definitions -> object (singleton..)
-    val CloneableAttr    = definitions.CloneableAttr.tpe
-    val TransientAtt     = definitions.TransientAttr.tpe
-    // remoting: the architectures are too different, no mapping (no portable code
-    // possible)
-
-    // java instance methods that are mapped to static methods in .net
-    // these will need to be called with OpCodes.Call (not Callvirt)
-    val dynToStatMapped = mutable.HashSet[Symbol]()
-
-    initMappings()
-
-    /** Create the mappings between java and .net classes and methods */
-    private def initMappings() {
-      mapType(definitions.AnyClass, MOBJECT)
-      mapType(definitions.AnyRefClass, MOBJECT)
-      //mapType(definitions.NullClass, clrTypes.getType("scala.AllRef$"))
-      //mapType(definitions.NothingClass, clrTypes.getType("scala.All$"))
-      // FIXME: for some reason the upper two lines map to null
-      mapType(definitions.NullClass, EXCEPTION)
-      mapType(definitions.NothingClass, EXCEPTION)
-
-      mapType(definitions.BooleanClass, MBOOL)
-      mapType(definitions.ByteClass, MBYTE)
-      mapType(definitions.ShortClass, MSHORT)
-      mapType(definitions.CharClass, MCHAR)
-      mapType(definitions.IntClass, MINT)
-      mapType(definitions.LongClass, MLONG)
-      mapType(definitions.FloatClass, MFLOAT)
-      mapType(definitions.DoubleClass, MDOUBLE)
-    }
-
-    var clasz: IClass = _
-    var method: IMethod = _
-
-    var massembly: AssemblyBuilder = _
-    var mmodule: ModuleBuilder = _
-    var mcode: ILGenerator = _
-
-    var assemName: String = _
-    var firstSourceName = ""
-    var outDir: File = _
-    var srcPath: File = _
-    var moduleName: String = _
-
-    def initAssembly() {
-
-      assemName = settings.assemname.value
-
-      if (assemName == "") {
-        if (entryPoint != null) {
-          assemName = msilName(entryPoint.enclClass)
-          // remove the $ at the end (from module-name)
-          assemName = assemName.substring(0, assemName.length() - 1)
-        } else {
-          // assuming filename of first source file
-          assert(firstSourceName.endsWith(".scala"), firstSourceName)
-          assemName = firstSourceName.substring(0, firstSourceName.length() - 6)
-        }
-      } else {
-        if (assemName.endsWith(".msil"))
-          assemName = assemName.substring(0, assemName.length()-5)
-        if (assemName.endsWith(".il"))
-          assemName = assemName.substring(0, assemName.length()-3)
-        val f: File = new File(assemName)
-        assemName = f.getName()
-      }
-
-      outDir = new File(settings.outdir.value)
-
-      srcPath = new File(settings.sourcedir.value)
-
-      val assemblyName = new AssemblyName()
-      assemblyName.Name = assemName
-      massembly = AssemblyBuilderFactory.DefineDynamicAssembly(assemblyName)
-
-      moduleName = assemName // + (if (entryPoint == null) ".dll" else ".exe")
-      // filename here: .dll or .exe (in both parameters), second: give absolute-path
-      mmodule = massembly.DefineDynamicModule(moduleName,
-                                              new File(outDir, moduleName).getAbsolutePath())
-      assert (mmodule != null)
-    }
-
-
-    /**
-     * Form of the custom Attribute parameter (Ecma-335.pdf)
-     *      - p. 163 for CustomAttrib Form,
-     *      - p. 164 for FixedArg Form (Array and Element) (if array or not is known!)
-     *  !! least significant byte first if values longer than one byte !!
-     *
-     * 1: Prolog (unsigned int16, value 0x0001) -> symtab[0] = 0x01, symtab[1] = 0x00
-     * 2: FixedArgs (directly the data, get number and types from related constructor)
-     *  2.1: length of the array (unsigned int32, 4 bytes, least significant first)
-     *  2.2: the byte array data
-     * 3: NumNamed (unsigned int16, number of named fields and properties, 0x0000)
-     */
-    def addSymtabAttribute(sym: Symbol, tBuilder: TypeBuilder) {
-      def addMarker() {
-        val markerSymtab = new Array[Byte](4)
-        markerSymtab(0) = 1.toByte
-        tBuilder.SetCustomAttribute(SYMTAB_ATTRIBUTE_EMPTY_CONSTRUCTOR, markerSymtab)
-      }
-
-      // both conditions are needed (why exactly..?)
-      if (tBuilder.Name.endsWith("$") || sym.isModuleClass) {
-        addMarker()
-      } else {
-        currentRun.symData.get(sym) match {
-          case Some(pickle) =>
-            var size = pickle.writeIndex
-            val symtab = new Array[Byte](size + 8)
-            symtab(0) = 1.toByte
-            for (i <- 2 until 6) {
-              symtab(i) = (size & 0xff).toByte
-              size = size >> 8
-            }
-            java.lang.System.arraycopy(pickle.bytes, 0, symtab, 6, pickle.writeIndex)
-
-            tBuilder.SetCustomAttribute(SYMTAB_ATTRIBUTE_CONSTRUCTOR, symtab)
-
-            currentRun.symData -= sym
-            currentRun.symData -= sym.companionSymbol
-
-          case _ =>
-            addMarker()
-        }
-      }
-    }
-
-    /**
-     * Mutates `member` adding CLR attributes (if any) based on sym.annotations.
-     * Please notice that CLR custom modifiers are a different beast (see customModifiers below)
-     * and thus shouldn't be added by this method.
-     */
-    def addAttributes(member: ICustomAttributeSetter, annotations: List[AnnotationInfo]) {
-      // val attributes = annotations.map(_.atp.typeSymbol).collect {
-      //   case definitions.TransientAttr => null // TODO this is just an example
-      // }
-      return // TODO: implement at some point
-    }
-
-    /**
-     * What's a CLR custom modifier? Intro available as source comments in compiler.msil.CustomModifier.
-     * It's basically a marker associated with a location (think of FieldInfo, ParameterInfo, and PropertyInfo)
-     * and thus that marker (be it optional or required) becomes part of the signature of that location.
-     * Some annotations will become CLR attributes (see addAttributes above), others custom modifiers (this method).
-     */
-    def customModifiers(annotations: List[AnnotationInfo]): Array[CustomModifier] = {
-      annotations.map(_.atp.typeSymbol).collect {
-        case definitions.VolatileAttr  => new CustomModifier(true, CustomModifier.VolatileMarker)
-      } toArray
-    }
-
-
-
-    /*
-      debuglog("creating annotations: " + annotations + " for member : " + member)
-      for (annot@ AnnotationInfo(typ, annArgs, nvPairs) <- annotations ;
-           if annot.isConstant)
-           //!typ.typeSymbol.isJavaDefined
-      {
-//        assert(consts.length <= 1,
-//               "too many constant arguments for annotations; "+consts.toString())
-
-        // Problem / TODO having the symbol of the annotations type would be nicer
-        // (i hope that type.typeSymbol is the same as the one in types2create)
-        // AND: this will crash if the annotations Type is already compiled (-> not a typeBuilder)
-        // when this is solved, types2create will be the same as icodes.classes, thus superfluous
-        val annType: TypeBuilder = getType(typ.typeSymbol).asInstanceOf[TypeBuilder]
-//        val annType: MsilType = getType(typ.typeSymbol)
-
-        // Problem / TODO: i have no idea which constructor is used. This
-        // information should be available in AnnotationInfo.
-        annType.CreateType() // else, GetConstructors can't be used
-        val constr: ConstructorInfo = annType.GetConstructors()(0)
-        // prevent a second call of CreateType, only needed because there's no
-        // other way than GetConstructors()(0) to get the constructor, if there's
-        // no constructor symbol available.
-
-        val args: Array[Byte] =
-          getAttributeArgs(
-            annArgs map (_.constant.get),
-            (for((n,v) <- nvPairs) yield (n, v.constant.get)))
-        member.SetCustomAttribute(constr, args)
-      }
-    } */
-
-/*    def getAttributeArgs(consts: List[Constant], nvPairs: List[(Name, Constant)]): Array[Byte] = {
-      val buf = ByteBuffer.allocate(2048) // FIXME: this may be not enough!
-      buf.order(java.nio.ByteOrder.LITTLE_ENDIAN)
-      buf.putShort(1.toShort) // signature
-
-      def emitSerString(str: String) = {
-          // this is wrong, it has to be the length of the UTF-8 byte array, which
-          // may be longer (see clr-book on page 302)
-//          val length: Int = str.length
-            val strBytes: Array[Byte] = try {
-              str.getBytes("UTF-8")
-            } catch {
-              case _: Error => abort("could not get byte-array for string: " + str)
-            }
-            val length: Int = strBytes.length //this length is stored big-endian
-            if (length < 128)
-              buf.put(length.toByte)
-            else if (length < (1<<14)) {
-              buf.put(((length >> 8) | 0x80).toByte) // the bits 14 and 15 of length are '0'
-              buf.put((length | 0xff).toByte)
-            } else if (length < (1 << 29)) {
-              buf.put(((length >> 24) | 0xc0).toByte)
-              buf.put(((length >> 16) & 0xff).toByte)
-              buf.put(((length >>  8) & 0xff).toByte)
-              buf.put(((length      ) & 0xff).toByte)
-            } else
-              abort("string too long for attribute parameter: " + length)
-            buf.put(strBytes)
-      }
-
-      def emitConst(const: Constant): Unit = const.tag match {
-        case BooleanTag => buf.put((if (const.booleanValue) 1 else 0).toByte)
-        case ByteTag => buf.put(const.byteValue)
-        case ShortTag => buf.putShort(const.shortValue)
-        case CharTag => buf.putChar(const.charValue)
-        case IntTag => buf.putInt(const.intValue)
-        case LongTag => buf.putLong(const.longValue)
-        case FloatTag => buf.putFloat(const.floatValue)
-        case DoubleTag => buf.putDouble(const.doubleValue)
-        case StringTag =>
-          val str: String = const.stringValue
-          if (str == null) {
-            buf.put(0xff.toByte)
-          } else {
-            emitSerString(str)
-          }
-        case ArrayTag =>
-          val arr: Array[Constant] = const.arrayValue
-          if (arr == null) {
-            buf.putInt(0xffffffff)
-          } else {
-            buf.putInt(arr.length)
-            arr.foreach(emitConst)
-          }
-
-        // TODO: other Tags: NoTag, UnitTag, ClazzTag, EnumTag, ArrayTag ???
-
-        case _ => abort("could not handle attribute argument: " + const)
-      }
-
-      consts foreach emitConst
-      buf.putShort(nvPairs.length.toShort)
-      def emitNamedArg(nvPair: (Name, Constant)) {
-        // the named argument is a property of the attribute (it can't be a field, since
-        //  all fields in scala are private)
-        buf.put(0x54.toByte)
-
-        def emitType(c: Constant) = c.tag match { // type of the constant, Ecma-335.pdf, page 151
-          case BooleanTag => buf.put(0x02.toByte)
-          case ByteTag =>    buf.put(0x05.toByte)
-          case ShortTag =>   buf.put(0x06.toByte)
-          case CharTag =>    buf.put(0x07.toByte)
-          case IntTag =>     buf.put(0x08.toByte)
-          case LongTag =>    buf.put(0x0a.toByte)
-          case FloatTag =>   buf.put(0x0c.toByte)
-          case DoubleTag =>  buf.put(0x0d.toByte)
-          case StringTag =>  buf.put(0x0e.toByte)
-
-          // TODO: other Tags: NoTag, UnitTag, ClazzTag, EnumTag ???
-
-          // ArrayTag falls in here
-          case _ => abort("could not handle attribute argument: " + c)
-        }
-
-        val cnst: Constant = nvPair._2
-        if (cnst.tag == ArrayTag) {
-          buf.put(0x1d.toByte)
-          emitType(cnst.arrayValue(0)) // FIXME: will crash if array length = 0
-        } else if (cnst.tag == EnumTag) {
-          buf.put(0x55.toByte)
-          // TODO: put a SerString (don't know what exactly, names of the enums somehow..)
-              } else {
-          buf.put(0x51.toByte)
-          emitType(cnst)
-        }
-
-        emitSerString(nvPair._1.toString)
-        emitConst(nvPair._2)
-      }
-
-      val length = buf.position()
-      buf.array().slice(0, length)
-    } */
-
-    def writeAssembly() {
-      if (entryPoint != null) {
-        assert(entryPoint.enclClass.isModuleClass, entryPoint.enclClass)
-        val mainMethod = methods(entryPoint)
-        val stringArrayTypes: Array[MsilType] = Array(MSTRING_ARRAY)
-        val globalMain = mmodule.DefineGlobalMethod(
-          "Main", MethodAttributes.Public | MethodAttributes.Static,
-          MVOID, stringArrayTypes)
-        globalMain.DefineParameter(0, ParameterAttributes.None, "args")
-        massembly.SetEntryPoint(globalMain)
-        val code = globalMain.GetILGenerator()
-        val moduleField = getModuleInstanceField(entryPoint.enclClass)
-        code.Emit(OpCodes.Ldsfld, moduleField)
-        code.Emit(OpCodes.Ldarg_0)
-        code.Emit(OpCodes.Callvirt, mainMethod)
-        code.Emit(OpCodes.Ret)
-      }
-      createTypes()
-      var outDirName: String = null
-      try {
-        if (settings.Ygenjavap.isDefault) { // we reuse the JVM-sounding setting because it's conceptually similar
-          outDirName = outDir.getPath()
-          massembly.Save(outDirName + "\\" + assemName + ".msil") /* use SingleFileILPrinterVisitor */
-        } else {
-          outDirName = srcPath.getPath()
-          massembly.Save(settings.Ygenjavap.value, outDirName)  /* use MultipleFilesILPrinterVisitor */
-        }
-      } catch {
-        case e:IOException => abort("Could not write to " + outDirName + ": " + e.getMessage())
-      }
-    }
-
-    private def createTypes() {
-      for (sym <- classes.keys) {
-        val iclass   = classes(sym)
-        val tBuilder = types(sym).asInstanceOf[TypeBuilder]
-
-        debuglog("Calling CreatType for " + sym + ", " + tBuilder.toString)
-
-        tBuilder.CreateType()
-        tBuilder.setSourceFilepath(iclass.cunit.source.file.path)
-      }
-    }
-
-    private[GenMSIL] def ilasmFileName(iclass: IClass) : String = {
-      // method.sourceFile contains just the filename
-      iclass.cunit.source.file.toString.replace("\\", "\\\\")
-    }
-
-    private[GenMSIL] def genClass(iclass: IClass) {
-      val sym = iclass.symbol
-      debuglog("Generating class " + sym + " flags: " + sym.flagString)
-      clasz = iclass
-
-      val tBuilder = getType(sym).asInstanceOf[TypeBuilder]
-      if (isCloneable(sym)) {
-        // FIXME: why there's no nme.clone_ ?
-        // "Clone": if the code is non-portable, "Clone" is defined, not "clone"
-        // TODO: improve condition (should override AnyRef.clone)
-        if (iclass.methods.forall(m => {
-          !((m.symbol.name.toString != "clone" || m.symbol.name.toString != "Clone") &&
-            m.symbol.tpe.paramTypes.length != 0)
-        })) {
-          debuglog("auto-generating cloneable method for " + sym)
-          val attrs: Short = (MethodAttributes.Public | MethodAttributes.Virtual |
-                              MethodAttributes.HideBySig).toShort
-          val cloneMethod = tBuilder.DefineMethod("Clone", attrs, MOBJECT,
-                                                  MsilType.EmptyTypes)
-          val clCode = cloneMethod.GetILGenerator()
-          clCode.Emit(OpCodes.Ldarg_0)
-          clCode.Emit(OpCodes.Call, MEMBERWISE_CLONE)
-          clCode.Emit(OpCodes.Ret)
-        }
-      }
-
-      val line = sym.pos.line
-      tBuilder.setPosition(line, ilasmFileName(iclass))
-
-      if (isTopLevelModule(sym)) {
-        if (sym.companionClass == NoSymbol)
-          generateMirrorClass(sym)
-        else
-          log("No mirror class for module with linked class: " +
-              sym.fullName)
-      }
-
-      addSymtabAttribute(sym, tBuilder)
-      addAttributes(tBuilder, sym.annotations)
-
-      if (iclass.symbol != definitions.ArrayClass)
-        iclass.methods foreach genMethod
-
-    } //genClass
-
-
-    private def genMethod(m: IMethod) {
-      debuglog("Generating method " + m.symbol + " flags: " + m.symbol.flagString +
-            " owner: " + m.symbol.owner)
-      method = m
-      localBuilders.clear
-      computeLocalVarsIndex(m)
-
-      if (m.symbol.isClassConstructor) {
-        mcode = constructors(m.symbol).asInstanceOf[ConstructorBuilder].GetILGenerator()
-      } else {
-        val mBuilder = methods(m.symbol).asInstanceOf[MethodBuilder]
-        if (!mBuilder.IsAbstract())
-          try {
-            mcode = mBuilder.GetILGenerator()
-          } catch {
-            case e: Exception =>
-              java.lang.System.out.println("m.symbol       = " + m.symbol.flagString + " " + m.symbol)
-              java.lang.System.out.println("m.symbol.owner = " + m.symbol.owner.flagString + " " + m.symbol.owner)
-              java.lang.System.out.println("mBuilder       = " + mBuilder)
-              java.lang.System.out.println("mBuilder.DeclaringType = " +
-                                 TypeAttributes.toString(mBuilder.DeclaringType.Attributes) +
-                                 "::" + mBuilder.DeclaringType)
-              throw e
-          }
-          else
-            mcode = null
-      }
-
-      if (mcode != null) {
-        for (local <- m.locals ; if !(m.params contains local)) {
-          debuglog("add local var: " + local + ", of kind " + local.kind)
-          val t: MsilType = msilType(local.kind)
-          val localBuilder = mcode.DeclareLocal(t)
-          localBuilder.SetLocalSymInfo(msilName(local.sym))
-          localBuilders(local) = localBuilder
-        }
-        genCode(m)
-      }
-
-    }
-
-    /** Special linearizer for methods with at least one exception handler. This
-     *  linearizer brings all basic blocks in the right order so that nested
-     *  try-catch and try-finally blocks can be emitted.
-     */
-    val msilLinearizer = new MSILLinearizer()
-
-    val labels = mutable.HashMap[BasicBlock, Label]()
-
-    /* when emitting .line, it's enough to include the full filename just once per method, thus reducing filesize.
-     * this scheme relies on the fact that the entry block is emitted first. */
-    var dbFilenameSeen = false
-
-    def genCode(m: IMethod) {
-
-      def makeLabels(blocks: List[BasicBlock]) = {
-        debuglog("Making labels for: " + method)
-        for (bb <- blocks) labels(bb) = mcode.DefineLabel()
-      }
-
-      labels.clear
-
-      var linearization = if(!m.exh.isEmpty) msilLinearizer.linearize(m)
-                          else linearizer.linearize(m)
-
-      if (!m.exh.isEmpty)
-        linearization = computeExceptionMaps(linearization, m)
-
-      makeLabels(linearization)
-
-      // debug val blocksInM = m.code.blocks.toList.sortBy(bb => bb.label)
-      // debug val blocksInL = linearization.sortBy(bb => bb.label)
-      // debug val MButNotL  = (blocksInM.toSet) diff (blocksInL.toSet) // if non-empty, a jump to B fails to find a label for B (case CJUMP, case CZJUMP)
-      // debug if(!MButNotL.isEmpty) { }
-
-      dbFilenameSeen = false
-      genBlocks(linearization)
-
-      // RETURN inside exception blocks are replaced by Leave. The target of the
-      // leave is a `Ret` outside any exception block (generated here).
-      if (handlerReturnMethod == m) {
-        mcode.MarkLabel(handlerReturnLabel)
-        if (handlerReturnKind != UNIT)
-          mcode.Emit(OpCodes.Ldloc, handlerReturnLocal)
-        mcode.Emit(OpCodes.Ret)
-      }
-
-      beginExBlock.clear()
-      beginCatchBlock.clear()
-      endExBlock.clear()
-      endFinallyLabels.clear()
-    }
-
-    def genBlocks(blocks: List[BasicBlock], previous: BasicBlock = null) {
-      blocks match {
-        case Nil => ()
-        case x :: Nil => genBlock(x, prev = previous, next = null)
-        case x :: y :: ys => genBlock(x, prev = previous, next = y); genBlocks(y :: ys, previous = x)
-      }
-    }
-
-    // the try blocks starting at a certain BasicBlock
-    val beginExBlock = mutable.HashMap[BasicBlock, List[ExceptionHandler]]()
-
-    // the catch blocks starting / endling at a certain BasicBlock
-    val beginCatchBlock = mutable.HashMap[BasicBlock, ExceptionHandler]()
-    val endExBlock = mutable.HashMap[BasicBlock, List[ExceptionHandler]]()
-
-    /** When emitting the code (genBlock), the number of currently active try / catch
-     *  blocks. When seeing a `RETURN` inside a try / catch, we need to
-     *   - store the result in a local (if it's not UNIT)
-     *   - emit `Leave handlerReturnLabel` instead of the Return
-     *   - emit code at the end: load the local and return its value
-     */
-    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
-    var handlerReturnLocal: LocalBuilder = _
-    // Label for a return instruction outside any exception block
-    var handlerReturnLabel: Label = _
-    // The result kind.
-    var handlerReturnKind: TypeKind = _
-    def returnFromHandler(kind: TypeKind): (LocalBuilder, Label) = {
-      if (handlerReturnMethod != method) {
-        handlerReturnMethod = method
-        if (kind != UNIT) {
-          handlerReturnLocal = mcode.DeclareLocal(msilType(kind))
-          handlerReturnLocal.SetLocalSymInfo("$handlerReturn")
-        }
-        handlerReturnLabel = mcode.DefineLabel()
-        handlerReturnKind = kind
-      }
-      (handlerReturnLocal, handlerReturnLabel)
-    }
-
-    /** For try/catch nested inside a finally, we can't use `Leave OutsideFinally`, the
-     *  Leave target has to be inside the finally (and it has to be the `endfinally` instruction).
-     *  So for every finalizer, we have a label which marks the place of the `endfinally`,
-     *  nested try/catch blocks will leave there.
-     */
-    val endFinallyLabels = mutable.HashMap[ExceptionHandler, Label]()
-
-    /** Computes which blocks are the beginning / end of a try or catch block */
-    private def computeExceptionMaps(blocks: List[BasicBlock], m: IMethod): List[BasicBlock] = {
-      val visitedBlocks = new mutable.HashSet[BasicBlock]()
-
-      // handlers which have not been introduced so far
-      var openHandlers = m.exh
-
-
-      /** Example
-       *   try {
-       *     try {
-       *         // *1*
-       *     } catch {
-       *       case h1 =>
-       *     }
-       *   } catch {
-       *     case h2 =>
-       *     case h3 =>
-       *       try {
-       *
-       *       } catch {
-       *         case h4 =>  // *2*
-       *         case h5 =>
-       *       }
-       *   }
-       */
-
-      // Stack of nested try blocks. Each bloc has a List of ExceptionHandler (multiple
-      // catch statements). Example *1*: Stack(List(h2, h3), List(h1))
-      val currentTryHandlers = new mutable.Stack[List[ExceptionHandler]]()
-
-      // Stack of nested catch blocks. The head of the list is the current catch block. The
-      // tail is all following catch blocks. Example *2*: Stack(List(h3), List(h4, h5))
-      val currentCatchHandlers = new mutable.Stack[List[ExceptionHandler]]()
-
-      for (b <- blocks) {
-
-        // are we past the current catch blocks?
-        def endHandlers(): List[ExceptionHandler] = {
-          var res: List[ExceptionHandler] = Nil
-          if (!currentCatchHandlers.isEmpty) {
-            val handler = currentCatchHandlers.top.head
-            if (!handler.blocks.contains(b)) {
-              // all blocks of the handler are either visited, or not part of the linearization (i.e. dead)
-              assert(handler.blocks.forall(b => visitedBlocks.contains(b) || !blocks.contains(b)),
-                     "Bad linearization of basic blocks inside catch. Found block not part of the handler\n"+
-                     b.fullString +"\nwhile in catch-part of\n"+ handler)
-
-              val rest = currentCatchHandlers.pop.tail
-              if (rest.isEmpty) {
-                // all catch blocks of that exception handler are covered
-                res = handler :: endHandlers()
-              } else {
-                // there are more catch blocks for that try (handlers covering the same)
-                currentCatchHandlers.push(rest)
-                beginCatchBlock(b) = rest.head
-              }
-            }
-          }
-          res
-        }
-        val end = endHandlers()
-        if (!end.isEmpty) endExBlock(b) = end
-
-        // are we past the current try block?
-        if (!currentTryHandlers.isEmpty) {
-          val handler = currentTryHandlers.top.head
-          if (!handler.covers(b)) {
-            // all of the covered blocks are visited, or not part of the linearization
-            assert(handler.covered.forall(b => visitedBlocks.contains(b) || !blocks.contains(b)),
-                   "Bad linearization of basic blocks inside try. Found non-covered block\n"+
-                   b.fullString +"\nwhile in try-part of\n"+ handler)
-
-            assert(handler.startBlock == b,
-                   "Bad linearization of basic blocks. The entry block of a catch does not directly follow the try\n"+
-                   b.fullString +"\n"+ handler)
-
-            val handlers = currentTryHandlers.pop
-            currentCatchHandlers.push(handlers)
-            beginCatchBlock(b) = handler
-          }
-        }
-
-        // are there try blocks starting at b?
-        val (newHandlers, stillOpen) = openHandlers.partition(_.covers(b))
-        openHandlers = stillOpen
-
-        val newHandlersBySize = newHandlers.groupBy(_.covered.size)
-        // big handlers first, smaller ones are nested inside the try of the big one
-        // (checked by the assertions below)
-        val sizes = newHandlersBySize.keys.toList.sortWith(_ > _)
-
-        val beginHandlers = new mutable.ListBuffer[ExceptionHandler]
-        for (s <- sizes) {
-          val sHandlers = newHandlersBySize(s)
-          for (h <- sHandlers) {
-            assert(h.covered == sHandlers.head.covered,
-                   "bad nesting of exception handlers. same size, but not covering same blocks\n"+
-                   h +"\n"+ sHandlers.head)
-            assert(h.resultKind == sHandlers.head.resultKind,
-                   "bad nesting of exception handlers. same size, but the same resultKind\n"+
-                   h +"\n"+ sHandlers.head)
-          }
-          for (bigger <- beginHandlers; h <- sHandlers) {
-            assert(h.covered.subsetOf(bigger.covered),
-                   "bad nesting of exception handlers. try blocks of smaller handler are not nested in bigger one.\n"+
-                   h +"\n"+ bigger)
-            assert(h.blocks.toSet.subsetOf(bigger.covered),
-                   "bad nesting of exception handlers. catch blocks of smaller handler are not nested in bigger one.\n"+
-                   h +"\n"+ bigger)
-          }
-          beginHandlers += sHandlers.head
-          currentTryHandlers.push(sHandlers)
-        }
-        beginExBlock(b) = beginHandlers.toList
-        visitedBlocks += b
-      }
-
-      // if there handlers left (i.e. handlers covering nothing, or a
-      // non-existent (dead) block), remove their catch-blocks.
-      val liveBlocks = if (openHandlers.isEmpty) blocks else {
-        blocks.filter(b => openHandlers.forall(h => !h.blocks.contains(b)))
-      }
-
-      /** There might be open handlers, but no more blocks. happens when try/catch end
-       *  with `throw` or `return`
-       *     def foo() { try { .. throw } catch { _ => .. throw } }
-       *
-       *  In this case we need some code after the catch block for the auto-generated
-       *  `leave` instruction. So we're adding a (dead) `throw new Exception`.
-       */
-      val rest = currentCatchHandlers.map(handlers => {
-        assert(handlers.length == 1, handlers)
-        handlers.head
-      }).toList
-
-      if (rest.isEmpty) {
-        liveBlocks
-      } else {
-        val b = m.code.newBlock
-        b.emit(Seq(
-          NEW(REFERENCE(definitions.ThrowableClass)),
-          DUP(REFERENCE(definitions.ObjectClass)),
-          CALL_METHOD(definitions.ThrowableClass.primaryConstructor, Static(true)),
-          THROW(definitions.ThrowableClass)
-        ))
-        b.close
-        endExBlock(b) = rest
-        liveBlocks ::: List(b)
-      }
-    }
-
-    /**
-     *  @param block the BasicBlock to emit code for
-     *  @param next  the following BasicBlock, `null` if `block` is the last one
-     */
-    def genBlock(block: BasicBlock, prev: BasicBlock, next: BasicBlock) {
-
-      def loadLocalOrAddress(local: Local, msg : String , loadAddr : Boolean) {
-        debuglog(msg + " for " + local)
-        val isArg = local.arg
-        val i = local.index
-        if (isArg)
-          loadArg(mcode, loadAddr)(i)
-        else
-          loadLocal(i, local, mcode, loadAddr)
-      }
-
-      def loadFieldOrAddress(field: Symbol, isStatic: Boolean, msg: String, loadAddr : Boolean) {
-        debuglog(msg + " with owner: " + field.owner +
-              " flags: " + field.owner.flagString)
-        val fieldInfo = fields.get(field) match {
-          case Some(fInfo) => fInfo
-          case None =>
-            val fInfo = getType(field.owner).GetField(msilName(field))
-            fields(field) = fInfo
-            fInfo
-        }
-        if (fieldInfo.IsVolatile) {
-          mcode.Emit(OpCodes.Volatile)
-        }
-        if (!fieldInfo.IsLiteral) {
-          if (loadAddr) {
-            mcode.Emit(if (isStatic) OpCodes.Ldsflda else OpCodes.Ldflda, fieldInfo)
-          } else {
-            mcode.Emit(if (isStatic) OpCodes.Ldsfld else OpCodes.Ldfld, fieldInfo)
-          }
-        } else {
-          assert(!loadAddr, "can't take AddressOf a literal field (not even with readonly. prefix) because no memory was allocated to such field ...")
-          // TODO the above can be overcome by loading the value, boxing, and finally unboxing. An address to a copy of the raw value will be on the stack.
-         /*  We perform `field inlining' as required by CLR.
-          *  Emit as for a CONSTANT ICode stmt, with the twist that the constant value is available
-          *  as a java.lang.Object and its .NET type allows constant initialization in CLR, i.e. that type
-          *  is one of I1, I2, I4, I8, R4, R8, CHAR, BOOLEAN, STRING, or CLASS (in this last case,
-          *  only accepting nullref as value). See Table 9-1 in Lidin's book on ILAsm. */
-          val value = fieldInfo.getValue()
-          if (value == null) {
-            mcode.Emit(OpCodes.Ldnull)
-          } else {
-            val typ = if (fieldInfo.FieldType.IsEnum) fieldInfo.FieldType.getUnderlyingType
-                      else fieldInfo.FieldType
-            if (typ == clrTypes.STRING) {
-              mcode.Emit(OpCodes.Ldstr, value.asInstanceOf[String])
-            } else if (typ == clrTypes.BOOLEAN) {
-                mcode.Emit(if (value.asInstanceOf[Boolean]) OpCodes.Ldc_I4_1
-                           else OpCodes.Ldc_I4_0)
-            } else if (typ == clrTypes.BYTE || typ == clrTypes.UBYTE) {
-              loadI4(value.asInstanceOf[Byte], mcode)
-            } else if (typ == clrTypes.SHORT || typ == clrTypes.USHORT) {
-              loadI4(value.asInstanceOf[Int], mcode)
-            } else if (typ == clrTypes.CHAR) {
-              loadI4(value.asInstanceOf[Char], mcode)
-            } else if (typ == clrTypes.INT || typ == clrTypes.UINT) {
-              loadI4(value.asInstanceOf[Int], mcode)
-            } else if (typ == clrTypes.LONG || typ == clrTypes.ULONG) {
-              mcode.Emit(OpCodes.Ldc_I8, value.asInstanceOf[Long])
-            } else if (typ == clrTypes.FLOAT) {
-              mcode.Emit(OpCodes.Ldc_R4, value.asInstanceOf[Float])
-            } else if (typ == clrTypes.DOUBLE) {
-              mcode.Emit(OpCodes.Ldc_R8, value.asInstanceOf[Double])
-            } else {
-              /* TODO one more case is described in Partition II, 16.2: bytearray(...) */
-              abort("Unknown type for static literal field: " + fieldInfo)
-            }
-          }
-        }
-      }
-
-      /** Creating objects works differently on .NET. On the JVM
-       *  - NEW(type) => reference on Stack
-       *  - DUP, load arguments, CALL_METHOD(constructor)
-       *
-       * On .NET, the NEW and DUP are ignored, but we emit a special method call
-       *  - load arguments
-       *  - NewObj(constructor) => reference on stack
-       *
-       * This variable tells whether the previous instruction was a NEW,
-       * we expect a DUP which is not emitted. */
-      var previousWasNEW = false
-
-      var lastLineNr: Int = 0
-      var lastPos: Position = NoPosition
-
-
-      // EndExceptionBlock must happen before MarkLabel because it adds the
-      // Leave instruction. Otherwise, labels(block) points to the Leave
-      // (inside the catch) instead of the instruction afterwards.
-      for (handlers <- endExBlock.get(block); exh <- handlers) {
-        currentHandlers.pop()
-        for (l <- endFinallyLabels.get(exh))
-          mcode.MarkLabel(l)
-        mcode.EndExceptionBlock()
-      }
-
-      mcode.MarkLabel(labels(block))
-      debuglog("Generating code for block: " + block)
-
-      for (handler <- beginCatchBlock.get(block)) {
-        if (!currentHandlers.isEmpty && currentHandlers.top.covered == handler.covered) {
-          currentHandlers.pop()
-          currentHandlers.push(handler)
-        }
-        if (handler.cls == NoSymbol) {
-          // `finally` blocks are represented the same as `catch`, but with no catch-type
-          mcode.BeginFinallyBlock()
-        } else {
-          val t = getType(handler.cls)
-          mcode.BeginCatchBlock(t)
-        }
-      }
-      for (handlers <- beginExBlock.get(block); exh <- handlers) {
-        currentHandlers.push(exh)
-        mcode.BeginExceptionBlock()
-      }
-
-      for (instr <- block) {
-        try {
-          val currentLineNr = instr.pos.line
-          val skip = if(instr.pos.isRange) instr.pos.sameRange(lastPos) else (currentLineNr == lastLineNr);
-          if(!skip || !dbFilenameSeen) {
-            val fileName = if(dbFilenameSeen) "" else {dbFilenameSeen = true; ilasmFileName(clasz)};
-            if(instr.pos.isRange) {
-              val startLine = instr.pos.focusStart.line
-              val endLine   = instr.pos.focusEnd.line
-              val startCol  = instr.pos.focusStart.column
-              val endCol    = instr.pos.focusEnd.column
-              mcode.setPosition(startLine, endLine, startCol, endCol, fileName)
-            } else {
-              mcode.setPosition(instr.pos.line, fileName)
-            }
-            lastLineNr = currentLineNr
-            lastPos = instr.pos
-          }
-        } catch { case _: UnsupportedOperationException => () }
-
-        if (previousWasNEW)
-          assert(instr.isInstanceOf[DUP], block)
-
-        instr match {
-          case THIS(clasz) =>
-            mcode.Emit(OpCodes.Ldarg_0)
-
-          case CONSTANT(const) =>
-            const.tag match {
-              case UnitTag    => ()
-              case BooleanTag => mcode.Emit(if (const.booleanValue) OpCodes.Ldc_I4_1
-                                            else OpCodes.Ldc_I4_0)
-              case ByteTag    => loadI4(const.byteValue, mcode)
-              case ShortTag   => loadI4(const.shortValue, mcode)
-              case CharTag    => loadI4(const.charValue, mcode)
-              case IntTag     => loadI4(const.intValue, mcode)
-              case LongTag    => mcode.Emit(OpCodes.Ldc_I8, const.longValue)
-              case FloatTag   => mcode.Emit(OpCodes.Ldc_R4, const.floatValue)
-              case DoubleTag  => mcode.Emit(OpCodes.Ldc_R8, const.doubleValue)
-              case StringTag  => mcode.Emit(OpCodes.Ldstr, const.stringValue)
-              case NullTag    => mcode.Emit(OpCodes.Ldnull)
-              case ClazzTag   =>
-                mcode.Emit(OpCodes.Ldtoken, msilType(const.typeValue))
-                mcode.Emit(OpCodes.Call, TYPE_FROM_HANDLE)
-              case _          => abort("Unknown constant value: " + const)
-            }
-
-          case LOAD_ARRAY_ITEM(kind) =>
-            (kind: @unchecked) match {
-              case BOOL           => mcode.Emit(OpCodes.Ldelem_I1)
-              case BYTE           => mcode.Emit(OpCodes.Ldelem_I1) // I1 for System.SByte, i.e. a scala.Byte
-              case SHORT          => mcode.Emit(OpCodes.Ldelem_I2)
-              case CHAR           => mcode.Emit(OpCodes.Ldelem_U2)
-              case INT            => mcode.Emit(OpCodes.Ldelem_I4)
-              case LONG           => mcode.Emit(OpCodes.Ldelem_I8)
-              case FLOAT          => mcode.Emit(OpCodes.Ldelem_R4)
-              case DOUBLE         => mcode.Emit(OpCodes.Ldelem_R8)
-              case REFERENCE(cls) => mcode.Emit(OpCodes.Ldelem_Ref)
-              case ARRAY(elem)    => mcode.Emit(OpCodes.Ldelem_Ref)
-
-              // case UNIT is not possible: an Array[Unit] will be an
-              //  Array[scala.runtime.BoxedUnit] (-> case REFERENCE)
-            }
-
-          case LOAD_LOCAL(local) => loadLocalOrAddress(local, "load_local", false)
-
-          case CIL_LOAD_LOCAL_ADDRESS(local) => loadLocalOrAddress(local, "cil_load_local_address", true)
-
-          case LOAD_FIELD(field, isStatic) => loadFieldOrAddress(field, isStatic, "load_field", false)
-
-          case CIL_LOAD_FIELD_ADDRESS(field, isStatic) => loadFieldOrAddress(field, isStatic, "cil_load_field_address", true)
-
-          case CIL_LOAD_ARRAY_ITEM_ADDRESS(kind) => mcode.Emit(OpCodes.Ldelema, msilType(kind))
-
-          case CIL_NEWOBJ(msym) =>
-            assert(msym.isClassConstructor)
-            val constructorInfo: ConstructorInfo = getConstructor(msym)
-            mcode.Emit(OpCodes.Newobj, constructorInfo)
-
-          case LOAD_MODULE(module) =>
-            debuglog("Generating LOAD_MODULE for: " + showsym(module))
-            mcode.Emit(OpCodes.Ldsfld, getModuleInstanceField(module))
-
-          case STORE_ARRAY_ITEM(kind) =>
-            (kind: @unchecked) match {
-              case BOOL           => mcode.Emit(OpCodes.Stelem_I1)
-              case BYTE           => mcode.Emit(OpCodes.Stelem_I1)
-              case SHORT          => mcode.Emit(OpCodes.Stelem_I2)
-              case CHAR           => mcode.Emit(OpCodes.Stelem_I2)
-              case INT            => mcode.Emit(OpCodes.Stelem_I4)
-              case LONG           => mcode.Emit(OpCodes.Stelem_I8)
-              case FLOAT          => mcode.Emit(OpCodes.Stelem_R4)
-              case DOUBLE         => mcode.Emit(OpCodes.Stelem_R8)
-              case REFERENCE(cls) => mcode.Emit(OpCodes.Stelem_Ref)
-              case ARRAY(elem)    => mcode.Emit(OpCodes.Stelem_Ref) // @TODO: test this! (occurs when calling a Array[Object]* vararg param method)
-
-              // case UNIT not possible (see comment at LOAD_ARRAY_ITEM)
-            }
-
-          case STORE_LOCAL(local) =>
-            val isArg = local.arg
-            val i = local.index
-            debuglog("store_local for " + local + ", index " + i)
-
-            // there are some locals defined by the compiler that
-            // are isArg and are need to be stored.
-            if (isArg) {
-              if (i >= -128 && i <= 127)
-                mcode.Emit(OpCodes.Starg_S, i)
-              else
-                mcode.Emit(OpCodes.Starg, i)
-            } else {
-              i match {
-                case 0 => mcode.Emit(OpCodes.Stloc_0)
-                case 1 => mcode.Emit(OpCodes.Stloc_1)
-                case 2 => mcode.Emit(OpCodes.Stloc_2)
-                case 3 => mcode.Emit(OpCodes.Stloc_3)
-                case _      =>
-                  if (i >= -128 && i <= 127)
-                    mcode.Emit(OpCodes.Stloc_S, localBuilders(local))
-                  else
-                    mcode.Emit(OpCodes.Stloc, localBuilders(local))
-              }
-            }
-
-          case STORE_THIS(_) =>
-            // this only works for impl classes because the self parameter comes first
-            // in the method signature. If that changes, this code has to be revisited.
-            mcode.Emit(OpCodes.Starg_S, 0)
-
-          case STORE_FIELD(field, isStatic) =>
-            val fieldInfo = fields.get(field) match {
-              case Some(fInfo) => fInfo
-              case None =>
-                val fInfo = getType(field.owner).GetField(msilName(field))
-                fields(field) = fInfo
-                fInfo
-            }
-            mcode.Emit(if (isStatic) OpCodes.Stsfld else OpCodes.Stfld, fieldInfo)
-
-          case CALL_PRIMITIVE(primitive) =>
-            genPrimitive(primitive, instr.pos)
-
-          case CALL_METHOD(msym, style) =>
-            if (msym.isClassConstructor) {
-              val constructorInfo: ConstructorInfo = getConstructor(msym)
-              (style: @unchecked) match {
-                // normal constructor calls are Static..
-                case Static(_) =>
-                  if (method.symbol.isClassConstructor && method.symbol.owner == msym.owner)
-                    // we're generating a constructor (method: IMethod is a constructor), and we're
-                    // calling another constructor of the same class.
-
-                    // @LUC TODO: this can probably break, namely when having: class A { def this() { new A() } }
-                    // instead, we should instruct the CALL_METHOD with additional information, know whether it's
-                    // an instance creation constructor call or not.
-                    mcode.Emit(OpCodes.Call, constructorInfo)
-                  else
-                    mcode.Emit(OpCodes.Newobj, constructorInfo)
-                case SuperCall(_) =>
-                  mcode.Emit(OpCodes.Call, constructorInfo)
-                  if (isStaticModule(clasz.symbol) &&
-                      notInitializedModules.contains(clasz.symbol) &&
-                      method.symbol.isClassConstructor)
-                    {
-                      notInitializedModules -= clasz.symbol
-                      mcode.Emit(OpCodes.Ldarg_0)
-                      mcode.Emit(OpCodes.Stsfld, getModuleInstanceField(clasz.symbol))
-                    }
-              }
-
-            } else {
-
-              var doEmit = true
-              getTypeOpt(msym.owner) match {
-                case Some(typ) if (typ.IsEnum) => {
-                  def negBool() = {
-                    mcode.Emit(OpCodes.Ldc_I4_0)
-                    mcode.Emit(OpCodes.Ceq)
-                  }
-                  doEmit = false
-                  val name = msym.name
-                  if (name eq nme.EQ)       { mcode.Emit(OpCodes.Ceq) }
-                  else if (name eq nme.NE)  { mcode.Emit(OpCodes.Ceq); negBool }
-                  else if (name eq nme.LT)  { mcode.Emit(OpCodes.Clt) }
-                  else if (name eq nme.LE)  { mcode.Emit(OpCodes.Cgt); negBool }
-                  else if (name eq nme.GT)  { mcode.Emit(OpCodes.Cgt) }
-                  else if (name eq nme.GE)  { mcode.Emit(OpCodes.Clt); negBool }
-                  else if (name eq nme.OR)  { mcode.Emit(OpCodes.Or) }
-                  else if (name eq nme.AND) { mcode.Emit(OpCodes.And) }
-                  else if (name eq nme.XOR) { mcode.Emit(OpCodes.Xor) }
-                  else
-                    doEmit = true
-                }
-                case _ => ()
-              }
-
-              // method: implicit view(FunctionX[PType0, PType1, ...,PTypeN, ResType]):DelegateType
-              val (isDelegateView, paramType, resType) = enteringTyper {
-                msym.tpe match {
-                  case MethodType(params, resultType)
-                  if (params.length == 1 && msym.name == nme.view_) =>
-                    val paramType = params(0).tpe
-                    val isDel = definitions.isCorrespondingDelegate(resultType, paramType)
-                    (isDel, paramType, resultType)
-                  case _ => (false, null, null)
-                }
-              }
-              if (doEmit && isDelegateView) {
-                doEmit = false
-                createDelegateCaller(paramType, resType)
-              }
-
-              if (doEmit &&
-                  (msym.name == nme.PLUS || msym.name == nme.MINUS)
-                  && clrTypes.isDelegateType(msilType(msym.owner.tpe)))
-                {
-                doEmit = false
-                val methodInfo: MethodInfo = getMethod(msym)
-                // call it as a static method, even if the compiler (symbol) thinks it's virtual
-                mcode.Emit(OpCodes.Call, methodInfo)
-                mcode.Emit(OpCodes.Castclass, msilType(msym.owner.tpe))
-              }
-
-              if (doEmit && definitions.Delegate_scalaCallers.contains(msym)) {
-                doEmit = false
-                val methodSym: Symbol = definitions.Delegate_scalaCallerTargets(msym)
-                val delegateType: Type = msym.tpe match {
-                  case MethodType(_, retType) => retType
-                  case _ => abort("not a method type: " + msym.tpe)
-                }
-                val methodInfo: MethodInfo = getMethod(methodSym)
-                val delegCtor = msilType(delegateType).GetConstructor(Array(MOBJECT, INT_PTR))
-                if (methodSym.isStatic) {
-                  mcode.Emit(OpCodes.Ldftn, methodInfo)
-                } else {
-                  mcode.Emit(OpCodes.Dup)
-                  mcode.Emit(OpCodes.Ldvirtftn, methodInfo)
-                }
-                mcode.Emit(OpCodes.Newobj, delegCtor)
-              }
-
-              if (doEmit) {
-                val methodInfo: MethodInfo = getMethod(msym)
-                (style: @unchecked) match {
-                  case SuperCall(_) =>
-                    mcode.Emit(OpCodes.Call, methodInfo)
-                  case Dynamic =>
-                    // methodInfo.DeclaringType is null for global methods
-                    val isValuetypeMethod = (methodInfo.DeclaringType ne null) && (methodInfo.DeclaringType.IsValueType)
-                    val isValuetypeVirtualMethod = isValuetypeMethod && (methodInfo.IsVirtual)
-                    if (dynToStatMapped(msym)) {
-                      mcode.Emit(OpCodes.Call, methodInfo)
-                    } else if (isValuetypeVirtualMethod) {
-                      mcode.Emit(OpCodes.Constrained, methodInfo.DeclaringType)
-                      mcode.Emit(OpCodes.Callvirt, methodInfo)
-                    } else if (isValuetypeMethod) {
-                      // otherwise error "Callvirt on a value type method" ensues
-                      mcode.Emit(OpCodes.Call, methodInfo)
-                    } else {
-                      mcode.Emit(OpCodes.Callvirt, methodInfo)
-                    }
-                  case Static(_) =>
-                    if(methodInfo.IsVirtual && !mcode.Ldarg0WasJustEmitted) {
-                      mcode.Emit(OpCodes.Callvirt, methodInfo)
-                    } else mcode.Emit(OpCodes.Call, methodInfo)
-              }
-            }
-            }
-
-          case BOX(boxType) =>
-            emitBox(mcode, boxType)
-
-          case UNBOX(boxType) =>
-            emitUnbox(mcode, boxType)
-
-          case CIL_UNBOX(boxType) =>
-            mcode.Emit(OpCodes.Unbox, msilType(boxType))
-
-          case CIL_INITOBJ(valueType) =>
-            mcode.Emit(OpCodes.Initobj, msilType(valueType))
-
-          case NEW(REFERENCE(cls)) =>
-            // the next instruction must be a DUP, see comment on `var previousWasNEW`
-            previousWasNEW = true
-
-          // works also for arrays and reference-types
-          case CREATE_ARRAY(elem, dims) =>
-            // TODO: handle multi dimensional arrays
-            assert(dims == 1, "Can't handle multi dimensional arrays")
-            mcode.Emit(OpCodes.Newarr, msilType(elem))
-
-          // works for arrays and reference-types
-          case IS_INSTANCE(tpe) =>
-            mcode.Emit(OpCodes.Isinst, msilType(tpe))
-            mcode.Emit(OpCodes.Ldnull)
-            mcode.Emit(OpCodes.Ceq)
-            mcode.Emit(OpCodes.Ldc_I4_0)
-            mcode.Emit(OpCodes.Ceq)
-
-          // works for arrays and reference-types
-          // part from the scala reference: "S <: T does not imply
-          //  Array[S] <: Array[T] in Scala. However, it is possible
-          //  to cast an array of S to an array of T if such a cast
-          //  is permitted in the host environment."
-          case CHECK_CAST(tpknd) =>
-            val tMSIL = msilType(tpknd)
-              mcode.Emit(OpCodes.Castclass, tMSIL)
-
-          // no SWITCH is generated when there's
-          //  - a default case ("case _ => ...") in the matching expr
-          //  - OR is used ("case 1 | 2 => ...")
-          case SWITCH(tags, branches) =>
-            // tags is List[List[Int]]; a list of integers for every label.
-            //    if the int on stack is 4, and 4 is in the second list => jump
-            //    to second label
-            // branches is List[BasicBlock]
-            //    the labels to jump to (the last one is the default one)
-
-            val switchLocal = mcode.DeclareLocal(MINT)
-            // several switch variables will appear with the same name in the
-            //  assembly code, but this makes no truble
-            switchLocal.SetLocalSymInfo("$switch_var")
-
-            mcode.Emit(OpCodes.Stloc, switchLocal)
-            var i = 0
-            for (l <- tags) {
-              val targetLabel = labels(branches(i))
-              for (i <- l) {
-                mcode.Emit(OpCodes.Ldloc, switchLocal)
-                loadI4(i, mcode)
-                mcode.Emit(OpCodes.Beq, targetLabel)
-              }
-              i += 1
-            }
-            val defaultTarget = labels(branches(i))
-            if (next != branches(i))
-              mcode.Emit(OpCodes.Br, defaultTarget)
-
-          case JUMP(whereto) =>
-            val (leaveHandler, leaveFinally, lfTarget) = leavesHandler(block, whereto)
-            if (leaveHandler) {
-              if (leaveFinally) {
-                if (lfTarget.isDefined) mcode.Emit(OpCodes.Leave, lfTarget.get)
-                else mcode.Emit(OpCodes.Endfinally)
-              } else
-                mcode.Emit(OpCodes.Leave, labels(whereto))
-            } else if (next != whereto)
-              mcode.Emit(OpCodes.Br, labels(whereto))
-
-          case CJUMP(success, failure, cond, kind) =>
-            // cond is TestOp (see Primitives.scala), and can take
-            // values EQ, NE, LT, GE LE, GT
-            // kind is TypeKind
-            val isFloat = kind == FLOAT || kind == DOUBLE
-            val emit = (c: TestOp, l: Label) => emitBr(c, l, isFloat)
-            emitCondBr(block, cond, success, failure, next, emit)
-
-          case CZJUMP(success, failure, cond, kind) =>
-            emitCondBr(block, cond, success, failure, next, emitBrBool(_, _))
-
-          case RETURN(kind) =>
-            if (currentHandlers.isEmpty)
-              mcode.Emit(OpCodes.Ret)
-            else {
-              val (local, label) = returnFromHandler(kind)
-              if (kind != UNIT)
-                mcode.Emit(OpCodes.Stloc, local)
-              mcode.Emit(OpCodes.Leave, label)
-            }
-
-          case THROW(_) =>
-            mcode.Emit(OpCodes.Throw)
-
-          case DROP(kind) =>
-            mcode.Emit(OpCodes.Pop)
-
-          case DUP(kind) =>
-            // see comment on `var previousWasNEW`
-            if (!previousWasNEW)
-              mcode.Emit(OpCodes.Dup)
-            else
-              previousWasNEW = false
-
-          case MONITOR_ENTER() =>
-            mcode.Emit(OpCodes.Call, MMONITOR_ENTER)
-
-          case MONITOR_EXIT() =>
-            mcode.Emit(OpCodes.Call, MMONITOR_EXIT)
-
-          case SCOPE_ENTER(_) | SCOPE_EXIT(_) | LOAD_EXCEPTION(_) =>
-            ()
-        }
-
-      } // end for (instr <- b) { .. }
-    } // end genBlock
-
-    def genPrimitive(primitive: Primitive, pos: Position) {
-      primitive match {
-        case Negation(kind) =>
-          kind match {
-            // CHECK: is ist possible to get this for BOOL? in this case, verify.
-            case BOOL | BYTE | CHAR | SHORT | INT | LONG | FLOAT | DOUBLE =>
-              mcode.Emit(OpCodes.Neg)
-
-            case _ => abort("Impossible to negate a " + kind)
-          }
-
-        case Arithmetic(op, kind) =>
-          op match {
-            case ADD => mcode.Emit(OpCodes.Add)
-            case SUB => mcode.Emit(OpCodes.Sub)
-            case MUL => mcode.Emit(OpCodes.Mul)
-            case DIV => mcode.Emit(OpCodes.Div)
-            case REM => mcode.Emit(OpCodes.Rem)
-            case NOT => mcode.Emit(OpCodes.Not) //bitwise complement (one's complement)
-            case _ => abort("Unknown arithmetic primitive " + primitive )
-          }
-
-        case Logical(op, kind) => op match {
-          case AND => mcode.Emit(OpCodes.And)
-          case OR => mcode.Emit(OpCodes.Or)
-          case XOR => mcode.Emit(OpCodes.Xor)
-        }
-
-        case Shift(op, kind) => op match {
-          case LSL => mcode.Emit(OpCodes.Shl)
-          case ASR => mcode.Emit(OpCodes.Shr)
-          case LSR => mcode.Emit(OpCodes.Shr_Un)
-        }
-
-        case Conversion(src, dst) =>
-          debuglog("Converting from: " + src + " to: " + dst)
-
-          dst match {
-            case BYTE =>   mcode.Emit(OpCodes.Conv_I1) // I1 for System.SByte, i.e. a scala.Byte
-            case SHORT =>  mcode.Emit(OpCodes.Conv_I2)
-            case CHAR =>   mcode.Emit(OpCodes.Conv_U2)
-            case INT =>    mcode.Emit(OpCodes.Conv_I4)
-            case LONG =>   mcode.Emit(OpCodes.Conv_I8)
-            case FLOAT =>  mcode.Emit(OpCodes.Conv_R4)
-            case DOUBLE => mcode.Emit(OpCodes.Conv_R8)
-            case _ =>
-              Console.println("Illegal conversion at: " + clasz +
-                              " at: " + pos.source + ":" + pos.line)
-          }
-
-        case ArrayLength(_) =>
-          mcode.Emit(OpCodes.Ldlen)
-
-        case StartConcat =>
-          mcode.Emit(OpCodes.Newobj, MSTRING_BUILDER_CONSTR)
-
-
-        case StringConcat(el) =>
-          val elemType : MsilType = el match {
-            case REFERENCE(_) | ARRAY(_) => MOBJECT
-            case _ => msilType(el)
-          }
-
-          val argTypes:Array[MsilType] = Array(elemType)
-          val stringBuilderAppend = MSTRING_BUILDER.GetMethod("Append", argTypes )
-          mcode.Emit(OpCodes.Callvirt,  stringBuilderAppend)
-
-        case EndConcat =>
-          mcode.Emit(OpCodes.Callvirt, MSTRING_BUILDER_TOSTRING)
-
-        case _ =>
-          abort("Unimplemented primitive " + primitive)
-      }
-    } // end genPrimitive
-
-
-    ////////////////////// loading ///////////////////////
-
-    def loadI4(value: Int, code: ILGenerator): Unit = value match {
-      case -1 => code.Emit(OpCodes.Ldc_I4_M1)
-      case 0  => code.Emit(OpCodes.Ldc_I4_0)
-      case 1  => code.Emit(OpCodes.Ldc_I4_1)
-      case 2  => code.Emit(OpCodes.Ldc_I4_2)
-      case 3  => code.Emit(OpCodes.Ldc_I4_3)
-      case 4  => code.Emit(OpCodes.Ldc_I4_4)
-      case 5  => code.Emit(OpCodes.Ldc_I4_5)
-      case 6  => code.Emit(OpCodes.Ldc_I4_6)
-      case 7  => code.Emit(OpCodes.Ldc_I4_7)
-      case 8  => code.Emit(OpCodes.Ldc_I4_8)
-      case _  =>
-        if (value >= -128 && value <= 127)
-          code.Emit(OpCodes.Ldc_I4_S, value)
-        else
-          code.Emit(OpCodes.Ldc_I4, value)
-    }
-
-    def loadArg(code: ILGenerator, loadAddr: Boolean)(i: Int) =
-      if (loadAddr) {
-        if (i >= -128 && i <= 127)
-          code.Emit(OpCodes.Ldarga_S, i)
-        else
-          code.Emit(OpCodes.Ldarga, i)
-      } else {
-        i match {
-          case 0 => code.Emit(OpCodes.Ldarg_0)
-          case 1 => code.Emit(OpCodes.Ldarg_1)
-          case 2 => code.Emit(OpCodes.Ldarg_2)
-          case 3 => code.Emit(OpCodes.Ldarg_3)
-          case _      =>
-            if (i >= -128 && i <= 127)
-              code.Emit(OpCodes.Ldarg_S, i)
-            else
-              code.Emit(OpCodes.Ldarg, i)
-        }
-      }
-
-    def loadLocal(i: Int, local: Local, code: ILGenerator, loadAddr: Boolean) =
-      if (loadAddr) {
-        if (i >= -128 && i <= 127)
-          code.Emit(OpCodes.Ldloca_S, localBuilders(local))
-        else
-          code.Emit(OpCodes.Ldloca, localBuilders(local))
-      } else {
-        i match {
-          case 0 => code.Emit(OpCodes.Ldloc_0)
-          case 1 => code.Emit(OpCodes.Ldloc_1)
-          case 2 => code.Emit(OpCodes.Ldloc_2)
-          case 3 => code.Emit(OpCodes.Ldloc_3)
-          case _      =>
-            if (i >= -128 && i <= 127)
-              code.Emit(OpCodes.Ldloc_S, localBuilders(local))
-            else
-              code.Emit(OpCodes.Ldloc, localBuilders(local))
-        }
-      }
-
-    ////////////////////// branches ///////////////////////
-
-    /** Returns a Triple (Boolean, Boolean, Option[Label])
-     *   - whether the jump leaves some exception block (try / catch / finally)
-     *   - whether it leaves a finally handler (finally block, but not it's try / catch)
-     *   - a label where to jump for leaving the finally handler
-     *     . None to leave directly using `endfinally`
-     *     . Some(label) to emit `leave label` (for try / catch inside a finally handler)
-     */
-    def leavesHandler(from: BasicBlock, to: BasicBlock): (Boolean, Boolean, Option[Label]) =
-      if (currentHandlers.isEmpty) (false, false, None)
-      else {
-        val h = currentHandlers.head
-        val leaveHead = { h.covers(from) != h.covers(to) ||
-                          h.blocks.contains(from) != h.blocks.contains(to) }
-        if (leaveHead) {
-          // we leave the innermost exception block.
-          // find out if we also leave som e `finally` handler
-          currentHandlers.find(e => {
-            e.cls == NoSymbol && e.blocks.contains(from) != e.blocks.contains(to)
-          }) match {
-            case Some(finallyHandler) =>
-              if (h == finallyHandler) {
-                // the finally handler is the innermost, so we can emit `endfinally` directly
-                (true, true, None)
-              } else {
-                // we need to `Leave` to the `endfinally` of the next outer finally handler
-                val l = endFinallyLabels.getOrElseUpdate(finallyHandler, mcode.DefineLabel())
-                (true, true, Some(l))
-              }
-            case None =>
-              (true, false, None)
-          }
-        } else (false, false, None)
-      }
-
-    def emitCondBr(block: BasicBlock, cond: TestOp, success: BasicBlock, failure: BasicBlock,
-                   next: BasicBlock, emitBrFun: (TestOp, Label) => Unit) {
-      val (sLeaveHandler, sLeaveFinally, slfTarget) = leavesHandler(block, success)
-      val (fLeaveHandler, fLeaveFinally, flfTarget) = leavesHandler(block, failure)
-
-      if (sLeaveHandler || fLeaveHandler) {
-        val sLabelOpt = if (sLeaveHandler) {
-          val leaveSLabel = mcode.DefineLabel()
-          emitBrFun(cond, leaveSLabel)
-          Some(leaveSLabel)
-        } else {
-          emitBrFun(cond, labels(success))
-          None
-        }
-
-        if (fLeaveHandler) {
-          if (fLeaveFinally) {
-            if (flfTarget.isDefined) mcode.Emit(OpCodes.Leave, flfTarget.get)
-            else mcode.Emit(OpCodes.Endfinally)
-          } else
-            mcode.Emit(OpCodes.Leave, labels(failure))
-        } else
-          mcode.Emit(OpCodes.Br, labels(failure))
-
-        sLabelOpt.map(l => {
-          mcode.MarkLabel(l)
-          if (sLeaveFinally) {
-            if (slfTarget.isDefined) mcode.Emit(OpCodes.Leave, slfTarget.get)
-            else mcode.Emit(OpCodes.Endfinally)
-          } else
-            mcode.Emit(OpCodes.Leave, labels(success))
-        })
-      } else {
-        if (next == success) {
-          emitBrFun(cond.negate, labels(failure))
-        } else {
-          emitBrFun(cond, labels(success))
-          if (next != failure) {
-            mcode.Emit(OpCodes.Br, labels(failure))
-          }
-        }
-      }
-    }
-
-    def emitBr(condition: TestOp, dest: Label, isFloat: Boolean) {
-      condition match {
-        case EQ => mcode.Emit(OpCodes.Beq, dest)
-        case NE => mcode.Emit(OpCodes.Bne_Un, dest)
-        case LT => mcode.Emit(if (isFloat) OpCodes.Blt_Un else OpCodes.Blt, dest)
-        case GE => mcode.Emit(if (isFloat) OpCodes.Bge_Un else OpCodes.Bge, dest)
-        case LE => mcode.Emit(if (isFloat) OpCodes.Ble_Un else OpCodes.Ble, dest)
-        case GT => mcode.Emit(if (isFloat) OpCodes.Bgt_Un else OpCodes.Bgt, dest)
-      }
-    }
-
-    def emitBrBool(cond: TestOp, dest: Label) {
-      (cond: @unchecked) match {
-        // EQ -> Brfalse, NE -> Brtrue; this is because we come from
-        // a CZJUMP. If the value on the stack is 0 (e.g. a boolean
-        // method returned false), and we are in the case EQ, then
-        // we need to emit Brfalse (EQ Zero means false). vice versa
-        case EQ => mcode.Emit(OpCodes.Brfalse, dest)
-        case NE => mcode.Emit(OpCodes.Brtrue, dest)
-      }
-    }
-
-    ////////////////////// local vars ///////////////////////
-
-    /**
-     * Compute the indexes of each local variable of the given
-     * method.
-     */
-    def computeLocalVarsIndex(m: IMethod) {
-      var idx = if (m.symbol.isStaticMember) 0 else 1
-
-      val params = m.params
-      for (l <- params) {
-        debuglog("Index value for parameter " + l + ": " + idx)
-        l.index = idx
-        idx += 1 // sizeOf(l.kind)
-      }
-
-      val locvars = m.locals filterNot (params contains)
-      idx = 0
-
-      for (l <- locvars) {
-        debuglog("Index value for local variable " + l + ": " + idx)
-        l.index = idx
-        idx += 1 // sizeOf(l.kind)
-      }
-
-    }
-
-    ////////////////////// Utilities ////////////////////////
-
-    /** Return the a name of this symbol that can be used on the .NET
-     * platform. It removes spaces from names.
-     *
-     * Special handling: scala.All and scala.AllRef are 'erased' to
-     * scala.All$ and scala.AllRef$. This is needed because they are
-     * not real classes, and they mean 'abrupt termination upon evaluation
-     * of that expression' or 'null' respectively. This handling is
-     * done already in GenICode, but here we need to remove references
-     * from method signatures to these types, because such classes can
-     * not exist in the classpath: the type checker will be very confused.
-     */
-    def msilName(sym: Symbol): String = {
-      val suffix = sym.moduleSuffix
-      // Flags.JAVA: "symbol was not defined by a scala-class" (java, or .net-class)
-
-      if (sym == definitions.NothingClass)
-        return "scala.runtime.Nothing$"
-      else if (sym == definitions.NullClass)
-        return "scala.runtime.Null$"
-
-      (if (sym.isClass || (sym.isModule && !sym.isMethod)) {
-        if (sym.isNestedClass) sym.simpleName
-        else sym.fullName
-       } else
-         sym.simpleName.toString.trim()) + suffix
-    }
-
-
-    ////////////////////// flags ///////////////////////
-
-    def msilTypeFlags(sym: Symbol): Int = {
-      var mf: Int = TypeAttributes.AutoLayout | TypeAttributes.AnsiClass
-
-      if(sym.isNestedClass) {
-        mf = mf | (if (sym hasFlag Flags.PRIVATE) TypeAttributes.NestedPrivate else TypeAttributes.NestedPublic)
-      } else {
-        mf = mf | (if (sym hasFlag Flags.PRIVATE) TypeAttributes.NotPublic else TypeAttributes.Public)
-      }
-      mf = mf | (if (sym hasFlag Flags.ABSTRACT) TypeAttributes.Abstract else 0)
-      mf = mf | (if (sym.isTrait && !sym.isImplClass) TypeAttributes.Interface else TypeAttributes.Class)
-      mf = mf | (if (sym isFinal) TypeAttributes.Sealed else 0)
-      mf
-      // static: not possible (or?)
-    }
-
-    def msilMethodFlags(sym: Symbol): Short = {
-      var mf: Int = MethodAttributes.HideBySig |
-        (if (sym hasFlag Flags.PRIVATE) MethodAttributes.Private
-         else MethodAttributes.Public)
-
-      if (!sym.isClassConstructor) {
-        if (sym.isStaticMember)
-          mf = mf | FieldAttributes.Static // coincidentally, same value as for MethodAttributes.Static ...
-        else {
-          mf = mf | MethodAttributes.Virtual
-          if (sym.isFinal && !getType(sym.owner).IsInterface)
-            mf = mf | MethodAttributes.Final
-          if (sym.isDeferred || getType(sym.owner).IsInterface)
-            mf = mf | MethodAttributes.Abstract
-        }
-      }
-
-      if (sym.isStaticMember) {
-        mf = mf | MethodAttributes.Static
-      }
-
-      // constructors of module classes should be private
-      if (sym.isPrimaryConstructor && isTopLevelModule(sym.owner)) {
-        mf |= MethodAttributes.Private
-        mf &= ~(MethodAttributes.Public)
-      }
-
-      mf.toShort
-    }
-
-    def msilFieldFlags(sym: Symbol): Short = {
-      var mf: Int =
-        if (sym hasFlag Flags.PRIVATE) FieldAttributes.Private
-        else if (sym hasFlag Flags.PROTECTED) FieldAttributes.FamORAssem
-        else FieldAttributes.Public
-
-      if (sym hasFlag Flags.FINAL)
-        mf = mf | FieldAttributes.InitOnly
-
-      if (sym.isStaticMember)
-        mf = mf | FieldAttributes.Static
-
-      // TRANSIENT: "not serialized", VOLATILE: doesn't exist on .net
-      // TODO: add this annotation also if the class has the custom attribute
-      // System.NotSerializedAttribute
-      sym.annotations.foreach( a => a match {
-        case AnnotationInfo(TransientAtt, _, _) =>
-          mf = mf | FieldAttributes.NotSerialized
-        case _ => ()
-      })
-
-      mf.toShort
-    }
-
-    ////////////////////// builders, types ///////////////////////
-
-    var entryPoint: Symbol = _
-
-    val notInitializedModules = mutable.HashSet[Symbol]()
-
-    // TODO: create fields also in def createType, and not in genClass,
-    // add a getField method (it only works as it is because fields never
-    // accessed from outside a class)
-
-    val localBuilders = mutable.HashMap[Local, LocalBuilder]()
-
-    private[GenMSIL] def findEntryPoint(cls: IClass) {
-
-      def isEntryPoint(sym: Symbol):Boolean = {
-        if (isStaticModule(sym.owner) && msilName(sym) == "main")
-          if (sym.tpe.paramTypes.length == 1) {
-            toTypeKind(sym.tpe.paramTypes(0)) match {
-              case ARRAY(elem) =>
-                if (elem.toType.typeSymbol == definitions.StringClass) {
-                  return true
-                }
-              case _ => ()
-            }
-          }
-        false
-      }
-
-      if((entryPoint == null) && settings.Xshowcls.isSetByUser) {  // TODO introduce dedicated setting instead
-        val entryclass = settings.Xshowcls.value.toString
-        val cfn = cls.symbol.fullName
-        if(cfn == entryclass) {
-          for (m <- cls.methods; if isEntryPoint(m.symbol)) { entryPoint = m.symbol }
-          if(entryPoint == null) { warning("Couldn't find main method in class " + cfn) }
-        }
-      }
-
-      if (firstSourceName == "")
-        if (cls.symbol.sourceFile != null) // is null for nested classes
-          firstSourceName = cls.symbol.sourceFile.name
-    }
-
-    // #####################################################################
-    // get and create types
-
-    private def msilType(t: TypeKind): MsilType = (t: @unchecked) match {
-      case UNIT           => MVOID
-      case BOOL           => MBOOL
-      case BYTE           => MBYTE
-      case SHORT          => MSHORT
-      case CHAR           => MCHAR
-      case INT            => MINT
-      case LONG           => MLONG
-      case FLOAT          => MFLOAT
-      case DOUBLE         => MDOUBLE
-      case REFERENCE(cls) => getType(cls)
-      case ARRAY(elem)    =>
-        msilType(elem) match {
-          // For type builders, cannot call "clrTypes.mkArrayType" because this looks up
-          // the type "tp" in the assembly (not in the HashMap "types" of the backend).
-          // This can fail for nested types because the builders are not complete yet.
-          case tb: TypeBuilder => tb.MakeArrayType()
-          case tp: MsilType => clrTypes.mkArrayType(tp)
-        }
-    }
-
-    private def msilType(tpe: Type): MsilType = msilType(toTypeKind(tpe))
-
-    private def msilParamTypes(sym: Symbol): Array[MsilType] = {
-      sym.tpe.paramTypes.map(msilType).toArray
-    }
-
-    def getType(sym: Symbol) = getTypeOpt(sym).getOrElse(abort(showsym(sym)))
-
-    /**
-     * Get an MSIL type from a symbol. First look in the clrTypes.types map, then
-     * lookup the name using clrTypes.getType
-     */
-    def getTypeOpt(sym: Symbol): Option[MsilType] = {
-      val tmp = types.get(sym)
-      tmp match {
-        case typ @ Some(_) => typ
-        case None =>
-          def typeString(sym: Symbol): String = {
-            val s = if (sym.isNestedClass) typeString(sym.owner) +"+"+ sym.simpleName
-                    else sym.fullName
-            if (sym.isModuleClass && !sym.isTrait) s + "$" else s
-          }
-          val name = typeString(sym)
-          val typ = clrTypes.getType(name)
-          if (typ == null)
-            None
-          else {
-            types(sym) = typ
-            Some(typ)
-          }
-      }
-    }
-
-    def mapType(sym: Symbol, mType: MsilType) {
-      assert(mType != null, showsym(sym))
-      types(sym) = mType
-    }
-
-    def createTypeBuilder(iclass: IClass) {
-      /**
-       * First look in the clrTypes.types map, if that fails check if it's a class being compiled, otherwise
-       * lookup by name (clrTypes.getType calls the static method msil.Type.GetType(fullname)).
-       */
-      def msilTypeFromSym(sym: Symbol): MsilType = {
-        types.get(sym).getOrElse {
-          classes.get(sym) match {
-            case Some(iclass) =>
-	              msilTypeBuilderFromSym(sym)
-            case None =>
-              getType(sym)
-          }
-        }
-      }
-
-      def msilTypeBuilderFromSym(sym: Symbol): TypeBuilder = {
-        if(!(types.contains(sym) && types(sym).isInstanceOf[TypeBuilder])){
-          val iclass = classes(sym)
-          assert(iclass != null)
-          createTypeBuilder(iclass)
-        }
-        types(sym).asInstanceOf[TypeBuilder]
-      }
-
-      val sym = iclass.symbol
-      if (types.contains(sym) && types(sym).isInstanceOf[TypeBuilder])
-        return
-
-      def isInterface(s: Symbol) = s.isTrait && !s.isImplClass
-      val parents: List[Type] =
-        if (sym.info.parents.isEmpty) List(definitions.ObjectClass.tpe)
-        else sym.info.parents.distinct
-
-      val superType : MsilType = if (isInterface(sym)) null else msilTypeFromSym(parents.head.typeSymbol)
-      debuglog("super type: " + parents(0).typeSymbol + ", msil type: " + superType)
-
-      val interfaces: Array[MsilType] =
-	parents.tail.map(p => msilTypeFromSym(p.typeSymbol)).toArray
-      if (parents.length > 1) {
-        if (settings.debug.value) {
-          log("interfaces:")
-          for (i <- 0.until(interfaces.length)) {
-            log("  type: " + parents(i + 1).typeSymbol + ", msil type: " + interfaces(i))
-          }
-        }
-      }
-
-      val tBuilder = if (sym.isNestedClass) {
-        val ownerT = msilTypeBuilderFromSym(sym.owner).asInstanceOf[TypeBuilder]
-        ownerT.DefineNestedType(msilName(sym), msilTypeFlags(sym), superType, interfaces)
-      } else {
-        mmodule.DefineType(msilName(sym), msilTypeFlags(sym), superType, interfaces)
-      }
-      mapType(sym, tBuilder)
-    } // createTypeBuilder
-
-    def createClassMembers(iclass: IClass) {
-      try {
-        createClassMembers0(iclass)
-      }
-      catch {
-        case e: Throwable =>
-          java.lang.System.err.println(showsym(iclass.symbol))
-          java.lang.System.err.println("with methods = " + iclass.methods)
-          throw e
-      }
-    }
-
-    def createClassMembers0(iclass: IClass) {
-
-      val mtype = getType(iclass.symbol).asInstanceOf[TypeBuilder]
-
-      for (ifield <- iclass.fields) {
-        val sym = ifield.symbol
-        debuglog("Adding field: " + sym.fullName)
-
-        val attributes = msilFieldFlags(sym)
-        val fieldTypeWithCustomMods =
-          new PECustomMod(msilType(sym.tpe),
-                          customModifiers(sym.annotations))
-        val fBuilder = mtype.DefineField(msilName(sym),
-                                         fieldTypeWithCustomMods,
-                                         attributes)
-        fields(sym) = fBuilder
-        addAttributes(fBuilder, sym.annotations)
-      } // all iclass.fields iterated over
-
-      if (isStaticModule(iclass.symbol)) {
-        val sc = iclass.lookupStaticCtor
-        if (sc.isDefined) {
-          val m = sc.get
-          val oldLastBlock = m.lastBlock
-          val lastBlock = m.newBlock()
-          oldLastBlock.replaceInstruction(oldLastBlock.length - 1, JUMP(lastBlock))
-          // call object's private ctor from static ctor
-          lastBlock.emit(CIL_NEWOBJ(iclass.symbol.primaryConstructor))
-          lastBlock.emit(DROP(toTypeKind(iclass.symbol.tpe)))
-          lastBlock emit RETURN(UNIT)
-          lastBlock.close
-        }
-      }
-
-      if (iclass.symbol != definitions.ArrayClass) {
-      for (m: IMethod <- iclass.methods) {
-        val sym = m.symbol
-        debuglog("Creating MethodBuilder for " + sym.flagString + " " +
-              sym.owner.fullName + "::" + sym.name)
-
-        val ownerType = getType(sym.enclClass).asInstanceOf[TypeBuilder]
-        assert(mtype == ownerType, "mtype = " + mtype + "; ownerType = " + ownerType)
-        val paramTypes = msilParamTypes(sym)
-        val attr = msilMethodFlags(sym)
-
-        if (m.symbol.isClassConstructor) {
-          val constr =
-            ownerType.DefineConstructor(attr, CallingConventions.Standard, paramTypes)
-          for (i <- 0.until(paramTypes.length)) {
-            constr.DefineParameter(i, ParameterAttributes.None, msilName(m.params(i).sym))
-          }
-          mapConstructor(sym, constr)
-          addAttributes(constr, sym.annotations)
-        } else {
-          val resType = msilType(m.returnType)
-          val method =
-            ownerType.DefineMethod(msilName(sym), attr, resType, paramTypes)
-          for (i <- 0.until(paramTypes.length)) {
-            method.DefineParameter(i, ParameterAttributes.None, msilName(m.params(i).sym))
-          }
-          if (!methods.contains(sym))
-            mapMethod(sym, method)
-          addAttributes(method, sym.annotations)
-          debuglog("\t created MethodBuilder " + method)
-        }
-      }
-      } // method builders created for non-array iclass
-
-      if (isStaticModule(iclass.symbol)) {
-        addModuleInstanceField(iclass.symbol)
-        notInitializedModules += iclass.symbol
-        if (iclass.lookupStaticCtor.isEmpty) {
-          addStaticInit(iclass.symbol)
-        }
-      }
-
-    } // createClassMembers0
-
-    private def isTopLevelModule(sym: Symbol): Boolean =
-      enteringRefchecks {
-        sym.isModuleClass && !sym.isImplClass && !sym.isNestedClass
-      }
-
-    // if the module is lifted it does not need to be initialized in
-    // its static constructor, and the MODULE$ field is not required.
-    // the outer class will care about it.
-    private def isStaticModule(sym: Symbol): Boolean = {
-      // .net inner classes: removed '!sym.hasFlag(Flags.LIFTED)', added
-      // 'sym.isStatic'. -> no longer compatible without skipping flatten!
-      sym.isModuleClass && sym.isStatic && !sym.isImplClass
-    }
-
-    private def isCloneable(sym: Symbol): Boolean = {
-      !sym.annotations.forall( a => a match {
-        case AnnotationInfo(CloneableAttr, _, _) => false
-        case _ => true
-      })
-    }
-
-    private def addModuleInstanceField(sym: Symbol) {
-      debuglog("Adding Module-Instance Field for " + showsym(sym))
-      val tBuilder = getType(sym).asInstanceOf[TypeBuilder]
-      val fb = tBuilder.DefineField(MODULE_INSTANCE_NAME,
-                           tBuilder,
-                           (FieldAttributes.Public |
-                            //FieldAttributes.InitOnly |
-                            FieldAttributes.Static).toShort)
-      fields(sym) = fb
-    }
-
-
-    // the symbol may be a object-symbol (module-symbol), or a module-class-symbol
-    private def getModuleInstanceField(sym: Symbol): FieldInfo = {
-      assert(sym.isModule || sym.isModuleClass, "Expected module: " + showsym(sym))
-
-      // when called by LOAD_MODULE, the corresponding type maybe doesn't
-      // exist yet -> make a getType
-      val moduleClassSym = if (sym.isModule) sym.moduleClass else sym
-
-      // TODO: get module field for modules not defined in the
-      // source currently compiling (e.g. Console)
-
-      fields get moduleClassSym match {
-        case Some(sym) => sym
-        case None =>
-          //val mclass = types(moduleClassSym)
-          val nameInMetadata = nestingAwareFullClassname(moduleClassSym)
-          val mClass = clrTypes.getType(nameInMetadata)
-          val mfield = mClass.GetField("MODULE$")
-          assert(mfield ne null, "module not found " + showsym(moduleClassSym))
-          fields(moduleClassSym) = mfield
-          mfield
-      }
-
-      //fields(moduleClassSym)
-    }
-
-    def nestingAwareFullClassname(csym: Symbol) : String = {
-      val suffix = csym.moduleSuffix
-      val res = if (csym.isNestedClass)
-        nestingAwareFullClassname(csym.owner) + "+" + csym.encodedName
-      else
-        csym.fullName
-      res + suffix
-    }
-
-    /** Adds a static initializer which creates an instance of the module
-     *  class (calls the primary constructor). A special primary constructor
-     *  will be generated (notInitializedModules) which stores the new instance
-     *  in the MODULE$ field right after the super call.
-     */
-    private def addStaticInit(sym: Symbol) {
-      val tBuilder = getType(sym).asInstanceOf[TypeBuilder]
-
-      val staticInit = tBuilder.DefineConstructor(
-        (MethodAttributes.Static | MethodAttributes.Public).toShort,
-        CallingConventions.Standard,
-        MsilType.EmptyTypes)
-
-      val sicode = staticInit.GetILGenerator()
-
-      val instanceConstructor = constructors(sym.primaryConstructor)
-
-      // there are no constructor parameters. assuming the constructor takes no parameter
-      // is fine: we call (in the static constructor) the constructor of the module class,
-      // which takes no arguments - an object definition cannot take constructor arguments.
-      sicode.Emit(OpCodes.Newobj, instanceConstructor)
-      // the stsfld is done in the instance constructor, just after the super call.
-      sicode.Emit(OpCodes.Pop)
-
-      sicode.Emit(OpCodes.Ret)
-    }
-
-    private def generateMirrorClass(sym: Symbol) {
-      assert(sym.isModuleClass, "Can't generate Mirror-Class for the Non-Module class " + sym)
-      debuglog("Dumping mirror class for object: " + sym)
-      val moduleName = msilName(sym)
-      val mirrorName = moduleName.substring(0, moduleName.length() - 1)
-      val mirrorTypeBuilder = mmodule.DefineType(mirrorName,
-                                                 TypeAttributes.Class |
-                                                 TypeAttributes.Public |
-                                                 TypeAttributes.Sealed,
-                                                 MOBJECT,
-                                                 MsilType.EmptyTypes)
-
-      val iclass = classes(sym)
-
-      for (m <- sym.tpe.nonPrivateMembers
-           if m.owner != definitions.ObjectClass && !m.isProtected &&
-           m.isMethod && !m.isClassConstructor && !m.isStaticMember && !m.isCase &&
-           !m.isDeferred)
-        {
-          debuglog("   Mirroring method: " + m)
-          val paramTypes = msilParamTypes(m)
-          val paramNames: Array[String] = new Array[String](paramTypes.length)
-          for (i <- 0 until paramTypes.length)
-            paramNames(i) = "x_" + i
-
-          // CHECK: verify if getMethodName is better than msilName
-          val mirrorMethod = mirrorTypeBuilder.DefineMethod(msilName(m),
-                                                            (MethodAttributes.Public |
-                                                            MethodAttributes.Static).toShort,
-                                                            msilType(m.tpe.resultType),
-                                                            paramTypes)
-
-          var i = 0
-          while (i < paramTypes.length) {
-            mirrorMethod.DefineParameter(i, ParameterAttributes.None, paramNames(i))
-            i += 1
-          }
-
-          val mirrorCode = mirrorMethod.GetILGenerator()
-          mirrorCode.Emit(OpCodes.Ldsfld, getModuleInstanceField(sym))
-          val mInfo = getMethod(m)
-          for (paramidx <- 0.until(paramTypes.length)) {
-            val mInfoParams = mInfo.GetParameters
-            val loadAddr = mInfoParams(paramidx).ParameterType.IsByRef
-            loadArg(mirrorCode, loadAddr)(paramidx)
-          }
-
-          mirrorCode.Emit(OpCodes.Callvirt, getMethod(m))
-          mirrorCode.Emit(OpCodes.Ret)
-        }
-
-      addSymtabAttribute(sym.sourceModule, mirrorTypeBuilder)
-
-      mirrorTypeBuilder.CreateType()
-      mirrorTypeBuilder.setSourceFilepath(iclass.cunit.source.file.path)
-    }
-
-
-    // #####################################################################
-    // delegate callers
-
-    var delegateCallers: TypeBuilder = _
-    var nbDelegateCallers: Int = 0
-
-    private def initDelegateCallers() = {
-      delegateCallers = mmodule.DefineType("$DelegateCallers", TypeAttributes.Public |
-                                          TypeAttributes.Sealed)
-    }
-
-    private def createDelegateCaller(functionType: Type, delegateType: Type) = {
-      if (delegateCallers == null)
-        initDelegateCallers()
-      // create a field an store the function-object
-      val mFunctionType: MsilType = msilType(functionType)
-      val anonfunField: FieldBuilder = delegateCallers.DefineField(
-        "$anonfunField$$" + nbDelegateCallers, mFunctionType,
-        (FieldAttributes.InitOnly | FieldAttributes.Public | FieldAttributes.Static).toShort)
-      mcode.Emit(OpCodes.Stsfld, anonfunField)
-
-
-      // create the static caller method and the delegate object
-      val (params, returnType) = delegateType.member(nme.apply).tpe match {
-        case MethodType(delParams, delReturn) => (delParams, delReturn)
-        case _ => abort("not a delegate type: "  + delegateType)
-      }
-      val caller: MethodBuilder = delegateCallers.DefineMethod(
-        "$delegateCaller$$" + nbDelegateCallers,
-        (MethodAttributes.Final | MethodAttributes.Public | MethodAttributes.Static).toShort,
-        msilType(returnType), (params map (_.tpe)).map(msilType).toArray)
-      for (i <- 0 until params.length)
-        caller.DefineParameter(i, ParameterAttributes.None, "arg" + i) // FIXME: use name of parameter symbol
-      val delegCtor = msilType(delegateType).GetConstructor(Array(MOBJECT, INT_PTR))
-      mcode.Emit(OpCodes.Ldnull)
-      mcode.Emit(OpCodes.Ldftn, caller)
-      mcode.Emit(OpCodes.Newobj, delegCtor)
-
-
-      // create the static caller method body
-      val functionApply: MethodInfo = getMethod(functionType.member(nme.apply))
-      val dcode: ILGenerator = caller.GetILGenerator()
-      dcode.Emit(OpCodes.Ldsfld, anonfunField)
-      for (i <- 0 until params.length) {
-        loadArg(dcode, false /* TODO confirm whether passing actual as-is to formal is correct wrt the ByRef attribute of the param */)(i)
-        emitBox(dcode, toTypeKind(params(i).tpe))
-      }
-      dcode.Emit(OpCodes.Callvirt, functionApply)
-      emitUnbox(dcode, toTypeKind(returnType))
-      dcode.Emit(OpCodes.Ret)
-
-      nbDelegateCallers = nbDelegateCallers + 1
-
-    } //def createDelegateCaller
-
-    def emitBox(code: ILGenerator, boxType: TypeKind) = (boxType: @unchecked) match {
-      // doesn't make sense, unit as parameter..
-      case UNIT   => code.Emit(OpCodes.Ldsfld, boxedUnit)
-      case BOOL | BYTE | SHORT | CHAR | INT | LONG | FLOAT | DOUBLE =>
-        code.Emit(OpCodes.Box, msilType(boxType))
-      case REFERENCE(cls) if clrTypes.isValueType(cls) =>
-        code.Emit(OpCodes.Box, (msilType(boxType)))
-      case REFERENCE(_) | ARRAY(_) =>
-        warning("Tried to BOX a non-valuetype.")
-        ()
-    }
-
-    def emitUnbox(code: ILGenerator, boxType: TypeKind) = (boxType: @unchecked) match {
-      case UNIT   => code.Emit(OpCodes.Pop)
-      /* (1) it's essential to keep the code emitted here (as of now plain calls to System.Convert.ToBlaBla methods)
-             behaviorally.equiv.wrt. BoxesRunTime.unboxToBlaBla methods
-             (case null: that's easy, case boxed: track changes to unboxBlaBla)
-         (2) See also: asInstanceOf to cast from Any to number,
-             tracked in http://lampsvn.epfl.ch/trac/scala/ticket/4437  */
-      case BOOL   => code.Emit(OpCodes.Call, toBool)
-      case BYTE   => code.Emit(OpCodes.Call, toSByte)
-      case SHORT  => code.Emit(OpCodes.Call, toShort)
-      case CHAR   => code.Emit(OpCodes.Call, toChar)
-      case INT    => code.Emit(OpCodes.Call, toInt)
-      case LONG   => code.Emit(OpCodes.Call, toLong)
-      case FLOAT  => code.Emit(OpCodes.Call, toFloat)
-      case DOUBLE => code.Emit(OpCodes.Call, toDouble)
-      case REFERENCE(cls) if clrTypes.isValueType(cls) =>
-        code.Emit(OpCodes.Unbox, msilType(boxType))
-        code.Emit(OpCodes.Ldobj, msilType(boxType))
-      case REFERENCE(_) | ARRAY(_) =>
-        warning("Tried to UNBOX a non-valuetype.")
-        ()
-    }
-
-    // #####################################################################
-    // get and create methods / constructors
-
-    def getConstructor(sym: Symbol): ConstructorInfo = constructors.get(sym) match {
-      case Some(constr) => constr
-      case None =>
-        val mClass = getType(sym.owner)
-        val constr = mClass.GetConstructor(msilParamTypes(sym))
-        if (constr eq null) {
-          java.lang.System.out.println("Cannot find constructor " + sym.owner + "::" + sym.name)
-          java.lang.System.out.println("scope = " + sym.owner.tpe.decls)
-          abort(sym.fullName)
-        }
-        else {
-          mapConstructor(sym, constr)
-          constr
-        }
-    }
-
-    def mapConstructor(sym: Symbol, cInfo: ConstructorInfo) = {
-      constructors(sym) = cInfo
-    }
-
-    private def getMethod(sym: Symbol): MethodInfo = {
-
-        methods.get(sym) match {
-        case Some(method) => method
-        case None =>
-          val mClass = getType(sym.owner)
-          try {
-            val method = mClass.GetMethod(msilName(sym), msilParamTypes(sym),
-                                          msilType(sym.tpe.resultType))
-            if (method eq null) {
-              java.lang.System.out.println("Cannot find method " + sym.owner + "::" + msilName(sym))
-              java.lang.System.out.println("scope = " + sym.owner.tpe.decls)
-              abort(sym.fullName)
-            }
-            else {
-              mapMethod(sym, method)
-              method
-            }
-          }
-          catch {
-            case e: Exception =>
-              Console.println("While looking up " + mClass + "::" + sym.nameString)
-            Console.println("\t" + showsym(sym))
-            throw e
-          }
-      }
-    }
-
-    /*
-     * add a mapping between sym and mInfo
-     */
-    private def mapMethod(sym: Symbol, mInfo: MethodInfo) {
-      assert (mInfo != null, mInfo)
-      methods(sym) = mInfo
-    }
-
-    private def showsym(sym: Symbol): String = (sym.toString +
-      "\n  symbol = " + sym.flagString + " " + sym +
-      "\n  owner  = " + sym.owner.flagString + " " + sym.owner
-    )
-
-  } // class BytecodeGenerator
-
-} // class GenMSIL
diff --git a/src/compiler/scala/tools/nsc/io/MsilFile.scala b/src/compiler/scala/tools/nsc/io/MsilFile.scala
deleted file mode 100644
index bda13a5ed0..0000000000
--- a/src/compiler/scala/tools/nsc/io/MsilFile.scala
+++ /dev/null
@@ -1,15 +0,0 @@
-/* NSC -- new Scala compiler
- * Copyright 2005-2013 LAMP/EPFL
- * @author  Paul Phillips
- */
-
-package scala.tools.nsc
-package io
-
-import ch.epfl.lamp.compiler.msil.{ Type => MsilType }
-
-/** This class wraps an MsilType.  It exists only so
- *  ClassPath can treat all of JVM/MSIL/bin/src files
- *  uniformly, as AbstractFiles.
- */
-class MsilFile(val msilType: MsilType) extends VirtualFile(msilType.FullName, msilType.Namespace) { }
diff --git a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala
index cf6579a696..8f964cf9e1 100644
--- a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala
+++ b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala
@@ -69,10 +69,6 @@ trait ScalaSettings extends AbsScalaSettings
    * -X "Advanced" settings
    */
   val Xhelp         = BooleanSetting    ("-X", "Print a synopsis of advanced options.")
-  val assemname     = StringSetting     ("-Xassem-name", "file", "(Requires -target:msil) Name of the output assembly.", "").dependsOn(target, "msil")
-  val assemrefs     = StringSetting     ("-Xassem-path", "path", "(Requires -target:msil) List of assemblies referenced by the program.", ".").dependsOn(target, "msil")
-  val assemextdirs  = StringSetting     ("-Xassem-extdirs", "dirs", "(Requires -target:msil) List of directories containing assemblies.  default:lib", Defaults.scalaLibDir.path).dependsOn(target, "msil")
-  val sourcedir     = StringSetting     ("-Xsourcedir", "directory", "(Requires -target:msil) Mirror source folder structure in output directory.", ".").dependsOn(target, "msil")
   val checkInit     = BooleanSetting    ("-Xcheckinit", "Wrap field accessors to throw an exception on uninitialized access.")
   val developer     = BooleanSetting    ("-Xdev", "Indicates user is a developer - issue warnings about anything which seems amiss")
   val noassertions  = BooleanSetting    ("-Xdisable-assertions", "Generate no assertions or assumptions.")
diff --git a/src/compiler/scala/tools/nsc/settings/StandardScalaSettings.scala b/src/compiler/scala/tools/nsc/settings/StandardScalaSettings.scala
index 98ef74aee3..6e5ac4f409 100644
--- a/src/compiler/scala/tools/nsc/settings/StandardScalaSettings.scala
+++ b/src/compiler/scala/tools/nsc/settings/StandardScalaSettings.scala
@@ -41,7 +41,7 @@ trait StandardScalaSettings {
   val optimise:        BooleanSetting // depends on post hook which mutates other settings
   val print =          BooleanSetting ("-print", "Print program with Scala-specific features removed.")
   val target =          ChoiceSetting ("-target", "target", "Target platform for object files. All JVM 1.5 targets are deprecated.",
-                                       List("jvm-1.5", "jvm-1.5-fjbg", "jvm-1.5-asm", "jvm-1.6", "jvm-1.7", "msil"),
+                                       List("jvm-1.5", "jvm-1.5-fjbg", "jvm-1.5-asm", "jvm-1.6", "jvm-1.7"),
                                        "jvm-1.6")
   val unchecked =      BooleanSetting ("-unchecked", "Enable additional warnings where generated code depends on assumptions.")
   val uniqid =         BooleanSetting ("-uniqid", "Uniquely tag all identifiers in debugging output.")
diff --git a/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala b/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala
index 19502f0d7e..bbff03f67f 100644
--- a/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala
+++ b/src/compiler/scala/tools/nsc/symtab/SymbolLoaders.scala
@@ -12,7 +12,7 @@ import scala.tools.nsc.util.{ ClassPath }
 import classfile.ClassfileParser
 import scala.reflect.internal.MissingRequirementError
 import scala.reflect.internal.util.Statistics
-import scala.tools.nsc.io.{ AbstractFile, MsilFile }
+import scala.tools.nsc.io.{ AbstractFile }
 
 /** This class ...
  *
@@ -152,7 +152,7 @@ abstract class SymbolLoaders {
     def sourcefile: Option[AbstractFile] = None
 
     /**
-     * Description of the resource (ClassPath, AbstractFile, MsilFile)
+     * Description of the resource (ClassPath, AbstractFile)
      * being processed by this loader
      */
     protected def description: String
@@ -265,16 +265,6 @@ abstract class SymbolLoaders {
     override def sourcefile: Option[AbstractFile] = classfileParser.srcfile
   }
 
-  class MsilFileLoader(msilFile: MsilFile) extends SymbolLoader with FlagAssigningCompleter {
-    private def typ = msilFile.msilType
-    private object typeParser extends clr.TypeParser {
-      val global: SymbolLoaders.this.global.type = SymbolLoaders.this.global
-    }
-
-    protected def description = "MsilFile "+ typ.FullName + ", assembly "+ typ.Assembly.FullName
-    protected def doComplete(root: Symbol) { typeParser.parse(typ, root) }
-  }
-
   class SourcefileLoader(val srcfile: AbstractFile) extends SymbolLoader with FlagAssigningCompleter {
     protected def description = "source file "+ srcfile.toString
     override def fromSource = true
@@ -287,11 +277,6 @@ abstract class SymbolLoaders {
     protected def doComplete(root: Symbol) { root.sourceModule.initialize }
   }
 
-  object clrTypes extends clr.CLRTypes {
-    val global: SymbolLoaders.this.global.type = SymbolLoaders.this.global
-    if (global.forMSIL) init()
-  }
-
   /** used from classfile parser to avoid cyclies */
   var parentsLevel = 0
   var pendingLoadActions: List[() => Unit] = Nil
diff --git a/src/compiler/scala/tools/nsc/symtab/clr/CLRTypes.scala b/src/compiler/scala/tools/nsc/symtab/clr/CLRTypes.scala
deleted file mode 100644
index 624db027f1..0000000000
--- a/src/compiler/scala/tools/nsc/symtab/clr/CLRTypes.scala
+++ /dev/null
@@ -1,132 +0,0 @@
-/* NSC -- new scala compiler
- * Copyright 2004-2013 LAMP/EPFL
- */
-
-
-package scala.tools.nsc
-package symtab
-package clr
-
-import ch.epfl.lamp.compiler.msil._
-import scala.collection.{ mutable, immutable }
-
-/**
- * Collects all types from all reference assemblies.
- */
-abstract class CLRTypes {
-
-  val global: Global
-  import global.Symbol
-
-  //##########################################################################
-
-  var BYTE: Type = _
-  var UBYTE: Type = _
-  var SHORT: Type = _
-  var USHORT: Type = _
-  var CHAR: Type = _
-  var INT: Type = _
-  var UINT: Type = _
-  var LONG: Type = _
-  var ULONG: Type = _
-  var FLOAT: Type = _
-  var DOUBLE: Type = _
-  var BOOLEAN: Type = _
-  var VOID: Type = _
-  var ENUM: Type = _
-  var DELEGATE: Type = _
-
-  var OBJECT: Type = _
-  var STRING: Type = _
-  var STRING_ARRAY: Type = _
-
-  var VALUE_TYPE: Type = _
-
-  var SCALA_SYMTAB_ATTR: Type = _
-  var SYMTAB_CONSTR: ConstructorInfo = _
-  var SYMTAB_DEFAULT_CONSTR: ConstructorInfo = _
-
-  var DELEGATE_COMBINE: MethodInfo = _
-  var DELEGATE_REMOVE: MethodInfo = _
-
-  val types: mutable.Map[Symbol,Type] = new mutable.HashMap
-  val constructors: mutable.Map[Symbol,ConstructorInfo] = new mutable.HashMap
-  val methods: mutable.Map[Symbol,MethodInfo] = new mutable.HashMap
-  val fields: mutable.Map[Symbol, FieldInfo] = new mutable.HashMap
-  val sym2type: mutable.Map[Type,Symbol] = new mutable.HashMap
-  val addressOfViews = new mutable.HashSet[Symbol]
-  val mdgptrcls4clssym: mutable.Map[ /*cls*/ Symbol, /*cls*/ Symbol] = new mutable.HashMap
-
-  def isAddressOf(msym : Symbol) = addressOfViews.contains(msym)
-
-  def isNonEnumValuetype(cls: Symbol) = {
-    val msilTOpt = types.get(cls)
-    val res = msilTOpt.isDefined && {
-      val msilT = msilTOpt.get
-      msilT.IsValueType && !msilT.IsEnum
-    }
-    res
-  }
-
-  def isValueType(cls: Symbol): Boolean = {
-    val opt = types.get(cls)
-    opt.isDefined && opt.get.IsValueType
-  }
-
-  def init() = try { // initialize
-    // the MsilClasspath (nsc/util/Classpath.scala) initializes the msil-library by calling
-    // Assembly.LoadFrom("mscorlib.dll"), so this type should be found
-    Type.initMSCORLIB(getTypeSafe("System.String").Assembly)
-
-    BYTE     = getTypeSafe("System.SByte")
-    UBYTE    = getTypeSafe("System.Byte")
-    CHAR     = getTypeSafe("System.Char")
-    SHORT    = getTypeSafe("System.Int16")
-    USHORT   = getTypeSafe("System.UInt16")
-    INT      = getTypeSafe("System.Int32")
-    UINT     = getTypeSafe("System.UInt32")
-    LONG     = getTypeSafe("System.Int64")
-    ULONG    = getTypeSafe("System.UInt64")
-    FLOAT    = getTypeSafe("System.Single")
-    DOUBLE   = getTypeSafe("System.Double")
-    BOOLEAN  = getTypeSafe("System.Boolean")
-    VOID     = getTypeSafe("System.Void")
-    ENUM     = getTypeSafe("System.Enum")
-    DELEGATE = getTypeSafe("System.MulticastDelegate")
-
-    OBJECT = getTypeSafe("System.Object")
-    STRING = getTypeSafe("System.String")
-    STRING_ARRAY = getTypeSafe("System.String[]")
-    VALUE_TYPE = getTypeSafe("System.ValueType")
-
-    SCALA_SYMTAB_ATTR = getTypeSafe("scala.runtime.SymtabAttribute")
-    val bytearray: Array[Type] = Array(Type.GetType("System.Byte[]"))
-    SYMTAB_CONSTR = SCALA_SYMTAB_ATTR.GetConstructor(bytearray)
-    SYMTAB_DEFAULT_CONSTR = SCALA_SYMTAB_ATTR.GetConstructor(Type.EmptyTypes)
-
-    val delegate: Type = getTypeSafe("System.Delegate")
-    val dargs: Array[Type] = Array(delegate, delegate)
-    DELEGATE_COMBINE = delegate.GetMethod("Combine", dargs)
-    DELEGATE_REMOVE = delegate.GetMethod("Remove", dargs)
-  }
-  catch {
-    case e: RuntimeException =>
-      Console.println(e.getMessage)
-      throw e
-  }
-
-  //##########################################################################
-  // type mapping and lookup
-
-  def getType(name: String): Type = Type.GetType(name)
-
-  def getTypeSafe(name: String): Type = {
-    val t = Type.GetType(name)
-    assert(t != null, name)
-    t
-  }
-
-  def mkArrayType(elemType: Type): Type = getType(elemType.FullName + "[]")
-
-  def isDelegateType(t: Type): Boolean = { t.BaseType() == DELEGATE }
-}  // CLRTypes
diff --git a/src/compiler/scala/tools/nsc/symtab/clr/TypeParser.scala b/src/compiler/scala/tools/nsc/symtab/clr/TypeParser.scala
deleted file mode 100644
index f0e49ce500..0000000000
--- a/src/compiler/scala/tools/nsc/symtab/clr/TypeParser.scala
+++ /dev/null
@@ -1,849 +0,0 @@
-/* NSC -- new scala compiler
- * Copyright 2004-2013 LAMP/EPFL
- */
-
-package scala.tools.nsc
-package symtab
-package clr
-
-import java.io.IOException
-import io.MsilFile
-import ch.epfl.lamp.compiler.msil.{Type => MSILType, Attribute => MSILAttribute, _}
-import scala.collection.{ mutable, immutable }
-import scala.reflect.internal.pickling.UnPickler
-import ch.epfl.lamp.compiler.msil.Type.TMVarUsage
-
-/**
- *  @author Nikolay Mihaylov
- */
-abstract class TypeParser {
-
-  val global: Global
-
-  import global._
-  import loaders.clrTypes
-
-  //##########################################################################
-
-  private var clazz: Symbol = _
-  private var instanceDefs: Scope = _   // was members
-  private var staticModule: Symbol = _  // was staticsClass
-  private var staticDefs: Scope = _     // was statics
-
-  protected def statics: Symbol = staticModule.moduleClass
-
-  protected var busy: Boolean = false       // lock to detect recursive reads
-
-  private object unpickler extends UnPickler {
-    val global: TypeParser.this.global.type = TypeParser.this.global
-  }
-
-  def parse(typ: MSILType, root: Symbol) {
-
-    def handleError(e: Throwable) = {
-      if (settings.debug.value) e.printStackTrace()  //debug
-      throw new IOException("type '" + typ.FullName + "' is broken\n(" + e.getMessage() + ")")
-    }
-    assert(!busy)
-    busy = true
-
-    if (root.isModule) {
-      this.clazz = root.companionClass
-      this.staticModule = root
-    } else {
-      this.clazz = root
-      this.staticModule = root.companionModule
-    }
-    try {
-      parseClass(typ)
-    } catch {
-      case e: FatalError => handleError(e)
-      case e: RuntimeException => handleError(e)
-    }
-    busy = false
-  }
-
-  class TypeParamsType(override val typeParams: List[Symbol]) extends LazyType with FlagAgnosticCompleter {
-    override def complete(sym: Symbol) { throw new AssertionError("cyclic type dereferencing") }
-  }
-
-  /* the names `classTParams` and `newTParams` stem from the forJVM version (ClassfileParser.sigToType())
-  *  but there are differences that should be kept in mind.
-  *  forMSIL, a nested class knows nothing about any type-params in the nesting class,
-  *  therefore newTParams is redundant (other than for recording lexical order),
-  *  it always contains the same elements as classTParams.value */
-  val classTParams = scala.collection.mutable.Map[Int,Symbol]() // TODO should this be a stack? (i.e., is it possible for >1 invocation to getCLRType on the same TypeParser instance be active )
-  val newTParams = new scala.collection.mutable.ListBuffer[Symbol]()
-  val methodTParams = scala.collection.mutable.Map[Int,Symbol]()
-
-  private def sig2typeBounds(tvarCILDef: GenericParamAndConstraints): Type = {
-    val ts = new scala.collection.mutable.ListBuffer[Type]
-    for (cnstrnt <- tvarCILDef.Constraints) {
-      ts += getCLRType(cnstrnt) // TODO we're definitely not at or after erasure, no need to call objToAny, right?
-    }
-    TypeBounds.upper(intersectionType(ts.toList, clazz))
-    // TODO variance???
-  }
-
-  private def createViewFromTo(viewSuffix : String, fromTpe : Type, toTpe : Type,
-                               addToboxMethodMap : Boolean, isAddressOf : Boolean) : Symbol = {
-    val flags = Flags.JAVA | Flags.STATIC | Flags.IMPLICIT; // todo: static? shouldn't be final instead?
-    val viewMethodType = (msym: Symbol) => JavaMethodType(msym.newSyntheticValueParams(List(fromTpe)), toTpe)
-    val vmsym = createMethod(nme.view_ + viewSuffix, flags, viewMethodType, null, true);
-    // !!! this used to mutate a mutable map in definitions, but that map became
-    // immutable and this kept "working" with a no-op.  So now it's commented out
-    // since I retired the deprecated code which allowed for that bug.
-    //
-    // if (addToboxMethodMap) definitions.boxMethod(clazz) = vmsym
-
-    if (isAddressOf) clrTypes.addressOfViews += vmsym
-    vmsym
-  }
-
-  private def createDefaultConstructor(typ: MSILType) {
-    val attrs = MethodAttributes.Public | MethodAttributes.RTSpecialName | MethodAttributes.SpecialName // TODO instance
-    val declType= typ
-    val method = new ConstructorInfo(declType, attrs, Array[MSILType]())
-    val flags = Flags.JAVA
-    val owner = clazz
-    val methodSym = owner.newMethod(nme.CONSTRUCTOR, NoPosition, flags)
-    val rettype = clazz.tpe
-    val mtype = methodType(Array[MSILType](), rettype);
-    val mInfo = mtype(methodSym)
-    methodSym.setInfo(mInfo)
-    instanceDefs.enter(methodSym);
-    clrTypes.constructors(methodSym) = method
-  }
-
-  private def parseClass(typ: MSILType) {
-
-    {
-      val t4c = clrTypes.types.get(clazz)
-      assert(t4c == None || t4c == Some(typ))
-    }
-    clrTypes.types(clazz) = typ
-
-    {
-      val c4t = clrTypes.sym2type.get(typ)
-      assert(c4t == None || c4t == Some(clazz))
-    }
-    clrTypes.sym2type(typ) = clazz
-
-    if (typ.IsDefined(clrTypes.SCALA_SYMTAB_ATTR, false)) {
-      val attrs = typ.GetCustomAttributes(clrTypes.SCALA_SYMTAB_ATTR, false);
-      assert (attrs.length == 1, attrs.length);
-      val a = attrs(0).asInstanceOf[MSILAttribute];
-      assert (a.getConstructor() == clrTypes.SYMTAB_CONSTR);
-      val symtab = a.getConstructorArguments()(0).asInstanceOf[Array[Byte]]
-      unpickler.unpickle(symtab, 0, clazz, staticModule, typ.FullName);
-      val mClass = clrTypes.getType(typ.FullName + "$");
-      if (mClass != null) {
-        clrTypes.types(statics) = mClass;
-        val moduleInstance = mClass.GetField("MODULE$");
-        assert (moduleInstance != null, mClass);
-        clrTypes.fields(statics) = moduleInstance;
-      }
-      return
-    }
-    val flags = translateAttributes(typ)
-
-    var clazzBoxed : Symbol = NoSymbol
-    var clazzMgdPtr : Symbol = NoSymbol
-
-    val canBeTakenAddressOf = (typ.IsValueType || typ.IsEnum) && (typ.FullName != "System.Enum")
-
-    if(canBeTakenAddressOf) {
-      clazzBoxed = clazz.owner.newClass(clazz.name.toTypeName append newTypeName("Boxed"))
-      clazzMgdPtr = clazz.owner.newClass(clazz.name.toTypeName append newTypeName("MgdPtr"))
-      clrTypes.mdgptrcls4clssym(clazz) =  clazzMgdPtr
-      /* adding typMgdPtr to clrTypes.sym2type should happen early (before metadata for supertypes is parsed,
-         before metadata for members are parsed) so that clazzMgdPtr can be found by getClRType. */
-      val typMgdPtr = MSILType.mkByRef(typ)
-      clrTypes.types(clazzMgdPtr) = typMgdPtr
-      clrTypes.sym2type(typMgdPtr) = clazzMgdPtr
-      /* clazzMgdPtr but not clazzBoxed is mapped by clrTypes.types into an msil.Type instance,
-         because there's no metadata-level representation for a "boxed valuetype" */
-      val instanceDefsMgdPtr = newScope
-      val classInfoMgdPtr = ClassInfoType(definitions.anyvalparam, instanceDefsMgdPtr, clazzMgdPtr)
-      clazzMgdPtr.setFlag(flags)
-      clazzMgdPtr.setInfo(classInfoMgdPtr)
-    }
-
-/* START CLR generics (snippet 1) */
-    // first pass
-    for (tvarCILDef <- typ.getSortedTVars() ) {
-      val tpname = newTypeName(tvarCILDef.Name.replaceAll("!", "")) // TODO are really all type-params named in all assemblies out there? (NO)
-      val tpsym = clazz.newTypeParameter(tpname)
-      classTParams.put(tvarCILDef.Number, tpsym)
-      newTParams += tpsym
-      // TODO wouldn't the following also be needed later, i.e. during getCLRType
-      tpsym.setInfo(definitions.AnyClass.tpe)
-    }
-    // second pass
-    for (tvarCILDef <- typ.getSortedTVars() ) {
-      val tpsym = classTParams(tvarCILDef.Number)
-      tpsym.setInfo(sig2typeBounds(tvarCILDef)) // we never skip bounds unlike in forJVM
-    }
-/* END CLR generics (snippet 1) */
-    val ownTypeParams = newTParams.toList
-/* START CLR generics (snippet 2) */
-    if (!ownTypeParams.isEmpty) {
-      clazz.setInfo(new TypeParamsType(ownTypeParams))
-      if(typ.IsValueType && !typ.IsEnum) {
-        clazzBoxed.setInfo(new TypeParamsType(ownTypeParams))
-      }
-    }
-/* END CLR generics (snippet 2) */
-    instanceDefs = newScope
-    staticDefs = newScope
-
-    val classInfoAsInMetadata = {
-        val ifaces: Array[MSILType] = typ.getInterfaces()
-        val superType = if (typ.BaseType() != null) getCLRType(typ.BaseType())
-                        else if (typ.IsInterface()) definitions.ObjectClass.tpe
-                        else definitions.AnyClass.tpe; // this branch activates for System.Object only.
-        // parents (i.e., base type and interfaces)
-        val parents = new scala.collection.mutable.ListBuffer[Type]()
-        parents += superType
-        for (iface <- ifaces) {
-          parents += getCLRType(iface)  // here the variance doesn't matter
-        }
-        // methods, properties, events, fields are entered in a moment
-        if (canBeTakenAddressOf) {
-          val instanceDefsBoxed = newScope
-          ClassInfoType(parents.toList, instanceDefsBoxed, clazzBoxed)
-        } else
-          ClassInfoType(parents.toList, instanceDefs, clazz)
-      }
-
-    val staticInfo = ClassInfoType(List(), staticDefs, statics)
-
-    clazz.setFlag(flags)
-
-    if (canBeTakenAddressOf) {
-      clazzBoxed.setInfo( if (ownTypeParams.isEmpty) classInfoAsInMetadata
-                          else genPolyType(ownTypeParams, classInfoAsInMetadata) )
-      clazzBoxed.setFlag(flags)
-      val rawValueInfoType = ClassInfoType(definitions.anyvalparam, instanceDefs, clazz)
-      clazz.setInfo( if (ownTypeParams.isEmpty) rawValueInfoType
-                     else genPolyType(ownTypeParams, rawValueInfoType) )
-    } else {
-      clazz.setInfo( if (ownTypeParams.isEmpty) classInfoAsInMetadata
-                     else genPolyType(ownTypeParams, classInfoAsInMetadata) )
-    }
-
-    // TODO I don't remember if statics.setInfo and staticModule.setInfo should also know about type params
-    statics.setFlag(Flags.JAVA)
-    statics.setInfo(staticInfo)
-    staticModule.setFlag(Flags.JAVA)
-    staticModule.setInfo(statics.tpe)
-
-
-    if (canBeTakenAddressOf) {
-      //  implicit conversions are owned by staticModule.moduleClass
-      createViewFromTo("2Boxed", clazz.tpe, clazzBoxed.tpe, addToboxMethodMap = true, isAddressOf = false)
-      // createViewFromTo("2Object", clazz.tpe, definitions.ObjectClass.tpe, addToboxMethodMap = true, isAddressOf = false)
-      createViewFromTo("2MgdPtr", clazz.tpe, clazzMgdPtr.tpe, addToboxMethodMap = false, isAddressOf = true)
-      // a return can't have type managed-pointer, thus a dereference-conversion is not needed
-      // similarly, a method can't declare as return type "boxed valuetype"
-      if (!typ.IsEnum) {
-        // a synthetic default constructor for raw-type allows `new X' syntax
-        createDefaultConstructor(typ)
-      }
-    }
-
-    // import nested types
-    for (ntype <- typ.getNestedTypes() if !(ntype.IsNestedPrivate || ntype.IsNestedAssembly || ntype.IsNestedFamANDAssem)
-				                                 || ntype.IsInterface /* TODO why shouldn't nested ifaces be type-parsed too? */ )
-      {
-        val loader = new loaders.MsilFileLoader(new MsilFile(ntype))
-              val nclazz = statics.newClass(ntype.Name)
-        val nmodule = statics.newModule(ntype.Name)
-	nclazz.setInfo(loader)
-	nmodule.setInfo(loader)
-	staticDefs.enter(nclazz)
-	staticDefs.enter(nmodule)
-
-	assert(nclazz.companionModule == nmodule, nmodule)
-	assert(nmodule.companionClass == nclazz, nclazz)
-      }
-
-    val fields = typ.getFields()
-    for (field <- fields
-         if !(field.IsPrivate() || field.IsAssembly() || field.IsFamilyAndAssembly)
-         if (getCLRType(field.FieldType) != null)
-         ) {
-      assert (!field.FieldType.IsPointer && !field.FieldType.IsByRef, "CLR requirement")
-      val flags = translateAttributes(field);
-      val name = newTermName(field.Name);
-      val fieldType =
-        if (field.IsLiteral && !field.FieldType.IsEnum && isDefinedAtgetConstant(getCLRType(field.FieldType)))
-	      ConstantType(getConstant(getCLRType(field.FieldType), field.getValue))
-	    else
-	      getCLRType(field.FieldType)
-      val owner = if (field.IsStatic()) statics else clazz;
-      val sym = owner.newValue(name, NoPosition, flags).setInfo(fieldType);
-        // TODO: set private within!!! -> look at typechecker/Namers.scala
-        (if (field.IsStatic()) staticDefs else instanceDefs).enter(sym);
-      clrTypes.fields(sym) = field;
-    }
-
-    for (constr <- typ.getConstructors() if !constr.IsStatic() && !constr.IsPrivate() &&
-         !constr.IsAssembly() && !constr.IsFamilyAndAssembly() && !constr.HasPtrParamOrRetType())
-      createMethod(constr);
-
-    // initially also contains getters and setters of properties.
-    val methodsSet = new mutable.HashSet[MethodInfo]();
-    methodsSet ++= typ.getMethods();
-
-    for (prop <- typ.getProperties) {
-      val propType: Type = getCLSType(prop.PropertyType);
-      if (propType != null) {
-	val getter: MethodInfo = prop.GetGetMethod(true);
-	val setter: MethodInfo = prop.GetSetMethod(true);
-	var gparamsLength: Int = -1;
-	if (!(getter == null || getter.IsPrivate || getter.IsAssembly
-              || getter.IsFamilyAndAssembly || getter.HasPtrParamOrRetType))
-	  {
-	    assert(prop.PropertyType == getter.ReturnType);
-	    val gparams: Array[ParameterInfo] = getter.GetParameters();
-	    gparamsLength = gparams.length;
-            val name: TermName = if (gparamsLength == 0) prop.Name else nme.apply;
-	    val flags = translateAttributes(getter);
-	    val owner: Symbol = if (getter.IsStatic) statics else clazz;
-            val methodSym = owner.newMethod(name, NoPosition, flags)
-      val mtype: Type = if (gparamsLength == 0) NullaryMethodType(propType) // .NET properties can't be polymorphic
-                        else methodType(getter, getter.ReturnType)(methodSym)
-        methodSym.setInfo(mtype);
-	    methodSym.setFlag(Flags.ACCESSOR);
-	    (if (getter.IsStatic) staticDefs else instanceDefs).enter(methodSym)
-	    clrTypes.methods(methodSym) = getter;
-	    methodsSet -= getter;
-	  }
-	if (!(setter == null || setter.IsPrivate || setter.IsAssembly
-             || setter.IsFamilyAndAssembly || setter.HasPtrParamOrRetType))
-	  {
-	    val sparams: Array[ParameterInfo] = setter.GetParameters()
-	    if(getter != null)
-	      assert(getter.IsStatic == setter.IsStatic);
-	    assert(setter.ReturnType == clrTypes.VOID);
-	    if(getter != null)
-	      assert(sparams.length == gparamsLength + 1, "" + getter + "; " + setter);
-
-            val name: TermName = if (gparamsLength == 0) nme.getterToSetter(prop.Name)
-			     else nme.update;
-	    val flags = translateAttributes(setter);
-	    val mtype = methodType(setter, definitions.UnitClass.tpe);
-	    val owner: Symbol = if (setter.IsStatic) statics else clazz;
-            val methodSym = owner.newMethod(name, NoPosition, flags)
-        methodSym.setInfo(mtype(methodSym))
-	    methodSym.setFlag(Flags.ACCESSOR);
-	    (if (setter.IsStatic) staticDefs else instanceDefs).enter(methodSym);
-	    clrTypes.methods(methodSym) = setter;
-	    methodsSet -= setter;
-	  }
-      }
-    }
-
-/*    for (event <- typ.GetEvents) {
-      // adding += and -= methods to add delegates to an event.
-      // raising the event ist not possible from outside the class (this is so
-      // generally in .net world)
-      val adder: MethodInfo = event.GetAddMethod();
-      val remover: MethodInfo = event.GetRemoveMethod();
-      if (!(adder == null || adder.IsPrivate || adder.IsAssembly
-	    || adder.IsFamilyAndAssembly))
-	{
-	  assert(adder.ReturnType == clrTypes.VOID);
-	  assert(adder.GetParameters().map(_.ParameterType).toList == List(event.EventHandlerType));
-	  val name = encode("+=");
-	  val flags = translateAttributes(adder);
-	  val mtype: Type = methodType(adder, adder.ReturnType);
-	  createMethod(name, flags, mtype, adder, adder.IsStatic)
-	  methodsSet -= adder;
-	}
-      if (!(remover == null || remover.IsPrivate || remover.IsAssembly
-	    || remover.IsFamilyAndAssembly))
-	{
-	  assert(remover.ReturnType == clrTypes.VOID);
-	  assert(remover.GetParameters().map(_.ParameterType).toList == List(event.EventHandlerType));
-	  val name = encode("-=");
-	  val flags = translateAttributes(remover);
-	  val mtype: Type = methodType(remover, remover.ReturnType);
-	  createMethod(name, flags, mtype, remover, remover.IsStatic)
-	  methodsSet -= remover;
-	}
-    } */
-
-/* Adds view amounting to syntax sugar for a CLR implicit overload.
-   The long-form syntax can also be supported if "methodsSet -= method" (last statement) is removed.
-
-    /* remember, there's typ.getMethods and type.GetMethods  */
-    for (method <- typ.getMethods)
-      if(!method.HasPtrParamOrRetType &&
-              method.IsPublic && method.IsStatic && method.IsSpecialName &&
-              method.Name == "op_Implicit") {
-        // create a view: typ => method's return type
-        val viewRetType: Type = getCLRType(method.ReturnType)
-        val viewParamTypes: List[Type] = method.GetParameters().map(_.ParameterType).map(getCLSType).toList;
-        /* The spec says "The operator method shall be defined as a static method on either the operand or return type."
-         *  We don't consider the declaring type for the purposes of definitions.functionType,
-         * instead we regard op_Implicit's argument type and return type as defining the view's signature.
-         */
-        if (viewRetType != null && !viewParamTypes.contains(null)) {
-          /* The check above applies e.g. to System.Decimal that has a conversion from UInt16, a non-CLS type, whose CLS-mapping returns null */
-          val funType: Type = definitions.functionType(viewParamTypes, viewRetType);
-          val flags = Flags.JAVA | Flags.STATIC | Flags.IMPLICIT; // todo: static? shouldn't be final instead?
-          val viewMethodType = (msym: Symbol) => JavaMethodType(msym.newSyntheticValueParams(viewParamTypes), funType)
-          val vmsym = createMethod(nme.view_, flags, viewMethodType, method, true);
-          methodsSet -= method;
-        }
-      }
-*/
-
-    for (method <- methodsSet.iterator)
-      if (!method.IsPrivate() && !method.IsAssembly() && !method.IsFamilyAndAssembly()
-           && !method.HasPtrParamOrRetType)
-        createMethod(method);
-
-    // Create methods and views for delegate support
-    if (clrTypes.isDelegateType(typ)) {
-      createDelegateView(typ)
-      createDelegateChainers(typ)
-    }
-
-    // for enumerations introduce comparison and bitwise logical operations;
-    // the backend will recognize them and replace them with comparison or
-    // bitwise logical operations on the primitive underlying type
-
-    if (typ.IsEnum) {
-      val ENUM_CMP_NAMES = List(nme.EQ, nme.NE, nme.LT, nme.LE, nme.GT, nme.GE);
-      val ENUM_BIT_LOG_NAMES = List(nme.OR, nme.AND, nme.XOR);
-
-      val flags = Flags.JAVA | Flags.FINAL
-      for (cmpName <- ENUM_CMP_NAMES) {
-        val enumCmp = clazz.newMethod(cmpName)
-        val enumCmpType = JavaMethodType(enumCmp.newSyntheticValueParams(List(clazz.tpe)), definitions.BooleanClass.tpe)
-        enumCmp.setFlag(flags).setInfo(enumCmpType)
-        instanceDefs.enter(enumCmp)
-      }
-
-      for (bitLogName <- ENUM_BIT_LOG_NAMES) {
-        val enumBitLog = clazz.newMethod(bitLogName)
-        val enumBitLogType = JavaMethodType(enumBitLog.newSyntheticValueParams(List(clazz.tpe)), clazz.tpe /* was classInfo, infinite typer */)
-        enumBitLog.setFlag(flags).setInfo(enumBitLogType)
-        instanceDefs.enter(enumBitLog)
-      }
-    }
-
-  } // parseClass
-
-  private def populateMethodTParams(method: MethodBase, methodSym: MethodSymbol) : List[Symbol] = {
-    if(!method.IsGeneric) Nil
-    else {
-      methodTParams.clear
-      val newMethodTParams = new scala.collection.mutable.ListBuffer[Symbol]()
-
-      // first pass
-      for (mvarCILDef <- method.getSortedMVars() ) {
-        val mtpname = newTypeName(mvarCILDef.Name.replaceAll("!", "")) // TODO are really all method-level-type-params named in all assemblies out there? (NO)
-        val mtpsym = methodSym.newTypeParameter(mtpname)
-        methodTParams.put(mvarCILDef.Number, mtpsym)
-        newMethodTParams += mtpsym
-        // TODO wouldn't the following also be needed later, i.e. during getCLRType
-        mtpsym.setInfo(definitions.AnyClass.tpe)
-      }
-      // second pass
-      for (mvarCILDef <- method.getSortedMVars() ) {
-        val mtpsym = methodTParams(mvarCILDef.Number)
-        mtpsym.setInfo(sig2typeBounds(mvarCILDef)) // we never skip bounds unlike in forJVM
-      }
-
-      newMethodTParams.toList
-    }
-  }
-
-  private def createMethod(method: MethodBase) {
-
-    val flags = translateAttributes(method);
-    val owner = if (method.IsStatic()) statics else clazz;
-    val methodSym = owner.newMethod(getName(method), NoPosition, flags)
-    /* START CLR generics (snippet 3) */
-    val newMethodTParams = populateMethodTParams(method, methodSym)
-    /* END CLR generics (snippet 3) */
-
-    val rettype = if (method.IsConstructor()) clazz.tpe
-                  else getCLSType(method.asInstanceOf[MethodInfo].ReturnType);
-    if (rettype == null) return;
-    val mtype = methodType(method, rettype);
-    if (mtype == null) return;
-/* START CLR generics (snippet 4) */
-    val mInfo = if (method.IsGeneric) genPolyType(newMethodTParams, mtype(methodSym))
-                else mtype(methodSym)
-/* END CLR generics (snippet 4) */
-/* START CLR non-generics (snippet 4)
-    val mInfo = mtype(methodSym)
-   END CLR non-generics (snippet 4) */
-    methodSym.setInfo(mInfo)
-    (if (method.IsStatic()) staticDefs else instanceDefs).enter(methodSym);
-    if (method.IsConstructor())
-      clrTypes.constructors(methodSym) = method.asInstanceOf[ConstructorInfo]
-    else clrTypes.methods(methodSym) = method.asInstanceOf[MethodInfo];
-  }
-
-  private def createMethod(name: TermName, flags: Long, args: Array[MSILType], retType: MSILType, method: MethodInfo, statik: Boolean): Symbol = {
-    val mtype = methodType(args, getCLSType(retType))
-    assert(mtype != null)
-    createMethod(name, flags, mtype, method, statik)
-  }
-
-  private def createMethod(name: TermName, flags: Long, mtype: Symbol => Type, method: MethodInfo, statik: Boolean): Symbol = {
-    val methodSym: Symbol = (if (statik)  statics else clazz).newMethod(name)
-    methodSym.setFlag(flags).setInfo(mtype(methodSym))
-    (if (statik) staticDefs else instanceDefs).enter(methodSym)
-    if (method != null)
-      clrTypes.methods(methodSym)  = method
-    methodSym
-  }
-
-  private def createDelegateView(typ: MSILType) = {
-    val invoke: MethodInfo = typ.GetMember("Invoke")(0).asInstanceOf[MethodInfo];
-    val invokeRetType: Type = getCLRType(invoke.ReturnType);
-    val invokeParamTypes: List[Type] =invoke.GetParameters().map(_.ParameterType).map(getCLSType).toList;
-    val funType: Type = definitions.functionType(invokeParamTypes, invokeRetType);
-
-    val typClrType: Type = getCLRType(typ);
-    val flags = Flags.JAVA | Flags.STATIC | Flags.IMPLICIT; // todo: static? think not needed
-
-    // create the forward view: delegate => function
-    val delegateParamTypes: List[Type] = List(typClrType);
-    // not ImplicitMethodType, this is for methods with implicit parameters (not implicit methods)
-    val forwardViewMethodType = (msym: Symbol) => JavaMethodType(msym.newSyntheticValueParams(delegateParamTypes), funType)
-    createMethod(nme.view_, flags, forwardViewMethodType, null, true);
-
-    // create the backward view: function => delegate
-    val functionParamTypes: List[Type] = List(funType);
-    val backwardViewMethodType = (msym: Symbol) => JavaMethodType(msym.newSyntheticValueParams(functionParamTypes), typClrType)
-    createMethod(nme.view_, flags, backwardViewMethodType, null, true);
-  }
-
-  private def createDelegateChainers(typ: MSILType) = {
-    val flags: Long = Flags.JAVA | Flags.FINAL
-    val args: Array[MSILType] = Array(typ)
-
-    var s = createMethod(encode("+="), flags, args, clrTypes.VOID, clrTypes.DELEGATE_COMBINE, false);
-    s = createMethod(encode("-="), flags, args, clrTypes.VOID, clrTypes.DELEGATE_REMOVE, false);
-
-    s = createMethod(nme.PLUS, flags, args, typ, clrTypes.DELEGATE_COMBINE, false);
-    s = createMethod(nme.MINUS, flags, args, typ, clrTypes.DELEGATE_REMOVE, false);
-  }
-
-  private def getName(method: MethodBase): TermName = {
-
-    def operatorOverload(name : String, paramsArity : Int) : Option[Name] = paramsArity match {
-      case 1 => name match {
-        // PartitionI.10.3.1
-        case "op_Decrement" => Some(encode("--"))
-        case "op_Increment" => Some(encode("++"))
-        case "op_UnaryNegation" => Some(nme.UNARY_-)
-        case "op_UnaryPlus" => Some(nme.UNARY_+)
-        case "op_LogicalNot" => Some(nme.UNARY_!)
-        case "op_OnesComplement" => Some(nme.UNARY_~)
-        /* op_True and op_False have no operator symbol assigned,
-           Other methods that will have to be written in full are:
-           op_AddressOf & (unary)
-           op_PointerDereference * (unary) */
-        case _ => None
-      }
-      case 2 => name match {
-        // PartitionI.10.3.2
-        case "op_Addition" => Some(nme.ADD)
-        case "op_Subtraction" => Some(nme.SUB)
-        case "op_Multiply" => Some(nme.MUL)
-        case "op_Division" => Some(nme.DIV)
-        case "op_Modulus" => Some(nme.MOD)
-        case "op_ExclusiveOr" => Some(nme.XOR)
-        case "op_BitwiseAnd" => Some(nme.AND)
-        case "op_BitwiseOr" => Some(nme.OR)
-        case "op_LogicalAnd" => Some(nme.ZAND)
-        case "op_LogicalOr" => Some(nme.ZOR)
-        case "op_LeftShift" => Some(nme.LSL)
-        case "op_RightShift" => Some(nme.ASR)
-        case "op_Equality" => Some(nme.EQ)
-        case "op_GreaterThan" => Some(nme.GT)
-        case "op_LessThan" => Some(nme.LT)
-        case "op_Inequality" => Some(nme.NE)
-        case "op_GreaterThanOrEqual" => Some(nme.GE)
-        case "op_LessThanOrEqual" => Some(nme.LE)
-
-        /* op_MemberSelection is reserved in Scala  */
-
-        /* The standard does not assign operator symbols to op_Assign , op_SignedRightShift , op_UnsignedRightShift ,
-         *   and op_UnsignedRightShiftAssignment so those names will be used instead to invoke those methods. */
-
-        /*
-          The remaining binary operators are not overloaded in C# and are therefore not in widespread use. They have to be written in full.
-
-          op_RightShiftAssignment      >>=
-          op_MultiplicationAssignment  *=
-          op_PointerToMemberSelection  ->*
-          op_SubtractionAssignment     -=
-          op_ExclusiveOrAssignment     ^=
-          op_LeftShiftAssignment       <<=
-          op_ModulusAssignment         %=
-          op_AdditionAssignment        +=
-          op_BitwiseAndAssignment      &=
-          op_BitwiseOrAssignment       |=
-          op_Comma                     ,
-          op_DivisionAssignment        /=
-        */
-        case _ => None
-      }
-      case _ => None
-    }
-
-    if (method.IsConstructor()) return nme.CONSTRUCTOR;
-    val name = method.Name;
-    if (method.IsStatic()) {
-      if(method.IsSpecialName) {
-        val paramsArity = method.GetParameters().size
-        // handle operator overload, otherwise handle as any static method
-        val operName = operatorOverload(name, paramsArity)
-        if (operName.isDefined) { return operName.get; }
-      }
-      return newTermName(name);
-    }
-    val params = method.GetParameters();
-    name match {
-      case "GetHashCode" if (params.length == 0) => nme.hashCode_;
-      case "ToString" if (params.length == 0) => nme.toString_;
-      case "Finalize" if (params.length == 0) => nme.finalize_;
-      case "Equals" if (params.length == 1 && params(0).ParameterType == clrTypes.OBJECT) =>
-        nme.equals_;
-      case "Invoke" if (clrTypes.isDelegateType(method.DeclaringType)) => nme.apply;
-      case _ => newTermName(name);
-    }
-  }
-
-  //##########################################################################
-
-  private def methodType(method: MethodBase, rettype: MSILType): Symbol => Type = {
-    val rtype = getCLSType(rettype);
-    if (rtype == null) null else methodType(method, rtype);
-  }
-
-  /** Return a method type for the given method. */
-  private def methodType(method: MethodBase, rettype: Type): Symbol => Type =
-    methodType(method.GetParameters().map(_.ParameterType), rettype);
-
-  /** Return a method type for the provided argument types and return type. */
-  private def methodType(argtypes: Array[MSILType], rettype: Type): Symbol => Type = {
-    def paramType(typ: MSILType): Type =
-      if (typ eq clrTypes.OBJECT) definitions.AnyClass.tpe // TODO a hack to compile scalalib, should be definitions.AnyRefClass.tpe
-      else getCLSType(typ);
-    val ptypes = argtypes.map(paramType).toList;
-    if (ptypes.contains(null)) null
-    else method => JavaMethodType(method.newSyntheticValueParams(ptypes), rettype);
-  }
-
-    //##########################################################################
-
-  private def getClassType(typ: MSILType): Type = {
-    assert(typ != null);
-    val res = rootMirror.getClassByName(typ.FullName.replace('+', '.') : TypeName).tpe;
-    //if (res.isError())
-    //  global.reporter.error("unknown class reference " + type.FullName);
-    res
-  }
-
-  private def getCLSType(typ: MSILType): Type = { // getCLS returns non-null for types GenMSIL can handle, be they CLS-compliant or not
-    if (typ.IsTMVarUsage())
-    /* START CLR generics (snippet 5) */
-      getCLRType(typ)
-    /* END CLR generics (snippet 5) */
-    /* START CLR non-generics (snippet 5)
-      null
-       END CLR non-generics (snippet 5) */
-    else if ( /* TODO hack if UBYE, uncommented, "ambiguous reference to overloaded definition" ensues, for example for System.Math.Max(x, y) */
-              typ == clrTypes.USHORT || typ == clrTypes.UINT || typ == clrTypes.ULONG
-      /*  || typ == clrTypes.UBYTE    */
-          ||  typ.IsNotPublic()      || typ.IsNestedPrivate()
-          ||  typ.IsNestedAssembly() || typ.IsNestedFamANDAssem()
-          ||  typ.IsPointer()
-          || (typ.IsArray() && getCLRType(typ.GetElementType()) == null)  /* TODO hack: getCLR instead of getCLS */
-          || (typ.IsByRef() && !typ.GetElementType().CanBeTakenAddressOf()))
-      null
-    else
-      getCLRType(typ)
-  }
-
-  private def getCLRTypeIfPrimitiveNullOtherwise(typ: MSILType): Type =
-    if (typ == clrTypes.OBJECT)
-      definitions.ObjectClass.tpe;
-    else if (typ == clrTypes.VALUE_TYPE)
-      definitions.AnyValClass.tpe
-    else if (typ == clrTypes.STRING)
-      definitions.StringClass.tpe;
-    else if (typ == clrTypes.VOID)
-      definitions.UnitClass.tpe
-    else if (typ == clrTypes.BOOLEAN)
-      definitions.BooleanClass.tpe
-    else if (typ == clrTypes.CHAR)
-      definitions.CharClass.tpe
-    else if ((typ == clrTypes.BYTE)  || (typ == clrTypes.UBYTE)) // TODO U... is a hack to compile scalalib
-      definitions.ByteClass.tpe
-    else if ((typ == clrTypes.SHORT) || (typ == clrTypes.SHORT)) // TODO U... is a hack to compile scalalib
-      definitions.ShortClass.tpe
-    else if ((typ == clrTypes.INT)   || (typ == clrTypes.UINT))  // TODO U... is a hack to compile scalalib
-      definitions.IntClass.tpe
-    else if ((typ == clrTypes.LONG)  || (typ == clrTypes.LONG))  // TODO U... is a hack to compile scalalib
-      definitions.LongClass.tpe
-    else if (typ == clrTypes.FLOAT)
-      definitions.FloatClass.tpe
-    else if (typ == clrTypes.DOUBLE)
-      definitions.DoubleClass.tpe
-    else null
-
-
-  private def getCLRType(tMSIL: MSILType): Type = {
-     var res = getCLRTypeIfPrimitiveNullOtherwise(tMSIL)
-     if (res != null) res
-     else if (tMSIL.isInstanceOf[ConstructedType]) {
-       val ct = tMSIL.asInstanceOf[ConstructedType]
-       /* START CLR generics (snippet 6) */
-             val cttpArgs = ct.typeArgs.map(tmsil => getCLRType(tmsil)).toList
-             appliedType(getCLRType(ct.instantiatedType), cttpArgs)
-       /* END CLR generics (snippet 6) */
-       /* START CLR non-generics (snippet 6)
-       getCLRType(ct.instantiatedType)
-          END CLR non-generics (snippet 6) */
-     } else if (tMSIL.isInstanceOf[TMVarUsage]) {
-        /* START CLR generics (snippet 7) */
-             val tVarUsage = tMSIL.asInstanceOf[TMVarUsage]
-             val tVarNumber = tVarUsage.Number
-             if (tVarUsage.isTVar) classTParams(tVarNumber).typeConstructor // shouldn't fail, just return definitions.AnyClass.tpe at worst
-             else methodTParams(tVarNumber).typeConstructor // shouldn't fail, just return definitions.AnyClass.tpe at worst
-        /* END CLR generics (snippet 7) */
-       /* START CLR non-generics (snippet 7)
-        null // definitions.ObjectClass.tpe
-          END CLR non-generics (snippet 7) */
-     } else if (tMSIL.IsArray()) {
-        var elemtp = getCLRType(tMSIL.GetElementType())
-        // cut&pasted from ClassfileParser
-        // make unbounded Array[T] where T is a type variable into Array[T with Object]
-        // (this is necessary because such arrays have a representation which is incompatible
-        // with arrays of primitive types).
-        // TODO does that incompatibility also apply to .NET?
-        if (elemtp.typeSymbol.isAbstractType && !(elemtp <:< definitions.ObjectClass.tpe))
-          elemtp = intersectionType(List(elemtp, definitions.ObjectClass.tpe))
-        appliedType(definitions.ArrayClass.tpe, List(elemtp))
-     } else {
-       res = clrTypes.sym2type.get(tMSIL) match {
-         case Some(sym) => sym.tpe
-         case None => if (tMSIL.IsByRef && tMSIL.GetElementType.IsValueType) {
-                        val addressed = getCLRType(tMSIL.GetElementType)
-                        val clasym = addressed.typeSymbolDirect // TODO should be .typeSymbol?
-                        clasym.info.load(clasym)
-                        val secondAttempt = clrTypes.sym2type.get(tMSIL)
-                        secondAttempt match { case Some(sym) => sym.tpe
-                                              case None => null
-                                            }
-                      } else getClassType(tMSIL)
-       }
-       if (res == null)
-         null // TODO new RuntimeException()
-       else res
-     }
-  }
-
-  // the values are Java-Box-Classes (e.g. Integer, Boolean, Character)
-  // java.lang.Number to get the value (if a number, not for boolean, character)
-  // see ch.epfl.lamp.compiler.msil.util.PEStream.java
-  def getConstant(constType: Type, value: Object): Constant = {
-    val typeClass = constType.typeSymbol
-    if (typeClass == definitions.BooleanClass)
-      Constant(value.asInstanceOf[java.lang.Boolean].booleanValue)
-    else if (typeClass == definitions.ByteClass)
-      Constant(value.asInstanceOf[java.lang.Number].byteValue)
-    else if (typeClass == definitions.ShortClass)
-      Constant(value.asInstanceOf[java.lang.Number].shortValue)
-    else if (typeClass == definitions.CharClass)
-      Constant(value.asInstanceOf[java.lang.Character].charValue)
-    else if (typeClass == definitions.IntClass)
-      Constant(value.asInstanceOf[java.lang.Number].intValue)
-    else if (typeClass == definitions.LongClass)
-      Constant(value.asInstanceOf[java.lang.Number].longValue)
-    else if (typeClass == definitions.FloatClass)
-      Constant(value.asInstanceOf[java.lang.Number].floatValue)
-    else if (typeClass == definitions.DoubleClass)
-      Constant(value.asInstanceOf[java.lang.Number].doubleValue)
-    else if (typeClass == definitions.StringClass)
-      Constant(value.asInstanceOf[java.lang.String])
-    else
-      abort("illegal value: " + value + ", class-symbol: " + typeClass)
-  }
-
-  def isDefinedAtgetConstant(constType: Type): Boolean = {
-    val typeClass = constType.typeSymbol
-    if (    (typeClass == definitions.BooleanClass)
-         || (typeClass == definitions.ByteClass)
-         || (typeClass == definitions.ShortClass)
-         || (typeClass == definitions.CharClass)
-         || (typeClass == definitions.IntClass)
-         || (typeClass == definitions.LongClass)
-         || (typeClass == definitions.FloatClass)
-         || (typeClass == definitions.DoubleClass)
-         || (typeClass == definitions.StringClass)
-       )
-      true
-    else
-      false
-  }
-
-  private def translateAttributes(typ: MSILType): Long = {
-    var flags: Long = Flags.JAVA;
-    if (typ.IsNotPublic() || typ.IsNestedPrivate()
-	|| typ.IsNestedAssembly() || typ.IsNestedFamANDAssem())
-      flags = flags | Flags.PRIVATE;
-    else if (typ.IsNestedFamily() || typ.IsNestedFamORAssem())
-      flags = flags | Flags.PROTECTED;
-    if (typ.IsAbstract())
-      flags = flags | Flags.ABSTRACT;
-    if (typ.IsSealed())
-      flags = flags | Flags.FINAL;
-    if (typ.IsInterface())
-      flags = flags | Flags.INTERFACE | Flags.TRAIT | Flags.ABSTRACT;
-
-    flags
-  }
-
-  private def translateAttributes(field: FieldInfo): Long = {
-    var flags: Long = Flags.JAVA;
-    if (field.IsPrivate() || field.IsAssembly() || field.IsFamilyAndAssembly())
-      flags = flags | Flags.PRIVATE;
-    else if (field.IsFamily() || field.IsFamilyOrAssembly())
-      flags = flags | Flags.PROTECTED;
-    if (field.IsInitOnly() || field.IsLiteral())
-      flags = flags | Flags.FINAL;
-    else
-      flags = flags | Flags.MUTABLE;
-    if (field.IsStatic)
-      flags = flags | Flags.STATIC
-
-    flags
-  }
-
-  private def translateAttributes(method: MethodBase): Long = {
-    var flags: Long = Flags.JAVA;
-    if (method.IsPrivate() || method.IsAssembly() || method.IsFamilyAndAssembly())
-      flags = flags | Flags.PRIVATE;
-    else if (method.IsFamily() || method.IsFamilyOrAssembly())
-      flags = flags | Flags.PROTECTED;
-    if (method.IsAbstract())
-      flags = flags | Flags.DEFERRED;
-    if (method.IsStatic)
-      flags = flags | Flags.STATIC
-
-    flags
-  }
-}
diff --git a/src/compiler/scala/tools/nsc/transform/CleanUp.scala b/src/compiler/scala/tools/nsc/transform/CleanUp.scala
index 847ca574a9..029eeab3e0 100644
--- a/src/compiler/scala/tools/nsc/transform/CleanUp.scala
+++ b/src/compiler/scala/tools/nsc/transform/CleanUp.scala
@@ -69,12 +69,6 @@ abstract class CleanUp extends Transform with ast.TreeDSL {
       case "mono-cache" => MONO_CACHE
       case "poly-cache" => POLY_CACHE
     }
-
-    def shouldRewriteTry(tree: Try) = {
-      val sym = tree.tpe.typeSymbol
-      forMSIL && (sym != UnitClass) && (sym != NothingClass)
-    }
-
     private def typedWithPos(pos: Position)(tree: Tree) =
       localTyper.typedPos(pos)(tree)
 
@@ -543,10 +537,9 @@ abstract class CleanUp extends Transform with ast.TreeDSL {
        * constructor. */
       case Template(parents, self, body) =>
         localTyper = typer.atOwner(tree, currentClass)
-        if (forMSIL) savingStatics( transformTemplate(tree) )
-        else transformTemplate(tree)
+        transformTemplate(tree)
 
-      case Literal(c) if (c.tag == ClazzTag) && !forMSIL=>
+      case Literal(c) if c.tag == ClazzTag =>
         val tpe = c.typeValue
         typedWithPos(tree.pos) {
           if (isPrimitiveValueClass(tpe.typeSymbol)) {
@@ -559,24 +552,6 @@ abstract class CleanUp extends Transform with ast.TreeDSL {
           else tree
         }
 
-      /* MSIL requires that the stack is empty at the end of a try-block.
-       * Hence, we here rewrite all try blocks with a result != {Unit, All} such that they
-       * store their result in a local variable. The catch blocks are adjusted as well.
-       * The try tree is subsituted by a block whose result expression is read of that variable. */
-      case theTry @ Try(block, catches, finalizer) if shouldRewriteTry(theTry) =>
-        def transformTry = {
-        val tpe = theTry.tpe.widen
-        val tempVar = currentOwner.newVariable(mkTerm(nme.EXCEPTION_RESULT_PREFIX), theTry.pos).setInfo(tpe)
-        def assignBlock(rhs: Tree) = super.transform(BLOCK(Ident(tempVar) === transform(rhs)))
-
-        val newBlock    = assignBlock(block)
-        val newCatches  = for (CaseDef(pattern, guard, body) <- catches) yield
-          (CASE(super.transform(pattern)) IF (super.transform(guard))) ==> assignBlock(body)
-        val newTry      = Try(newBlock, newCatches, super.transform(finalizer))
-
-        typedWithPos(theTry.pos)(BLOCK(VAL(tempVar) === EmptyTree, newTry, Ident(tempVar)))
-        }
-        transformTry
      /*
       * This transformation should identify Scala symbol invocations in the tree and replace them
       * with references to a static member. Also, whenever a class has at least a single symbol invocation
diff --git a/src/compiler/scala/tools/nsc/transform/Mixin.scala b/src/compiler/scala/tools/nsc/transform/Mixin.scala
index ac1cdd1f46..135660ed27 100644
--- a/src/compiler/scala/tools/nsc/transform/Mixin.scala
+++ b/src/compiler/scala/tools/nsc/transform/Mixin.scala
@@ -513,7 +513,7 @@ abstract class Mixin extends InfoTransform with ast.TreeDSL {
      *       - create a new method definition that also has a `self` parameter
      *         (which comes first) Iuli: this position is assumed by tail call elimination
      *         on a different receiver. Storing a new 'this' assumes it is located at
-     *         index 0 in the local variable table. See 'STORE_THIS' and GenJVM/GenMSIL.
+     *         index 0 in the local variable table. See 'STORE_THIS' and GenASM.
      *   - Map implementation class types in type-apply's to their interfaces
      *   - Remove all fields in implementation classes
      */
diff --git a/src/compiler/scala/tools/nsc/transform/TailCalls.scala b/src/compiler/scala/tools/nsc/transform/TailCalls.scala
index 6ab99eaec6..7cad2b3986 100644
--- a/src/compiler/scala/tools/nsc/transform/TailCalls.scala
+++ b/src/compiler/scala/tools/nsc/transform/TailCalls.scala
@@ -149,7 +149,7 @@ abstract class TailCalls extends Transform {
       def enclosingType    = method.enclClass.typeOfThis
       def isEligible       = method.isEffectivelyFinal
       // @tailrec annotation indicates mandatory transformation
-      def isMandatory      = method.hasAnnotation(TailrecClass) && !forMSIL
+      def isMandatory      = method.hasAnnotation(TailrecClass)
       def isTransformed    = isEligible && accessed(label)
       def tailrecFailure() = unit.error(failPos, "could not optimize @tailrec annotated " + method + ": " + failReason)
 
@@ -229,7 +229,6 @@ abstract class TailCalls extends Transform {
         }
         else if (!matchesTypeArgs)      failHere("it is called recursively with different type arguments")
         else if (receiver == EmptyTree) rewriteTailCall(This(currentClass))
-        else if (forMSIL)               fail("it cannot be optimized on MSIL")
         else if (!receiverIsSame)       failHere("it changes type of 'this' on a polymorphic recursive call")
         else                            rewriteTailCall(receiver)
       }
diff --git a/src/compiler/scala/tools/nsc/transform/UnCurry.scala b/src/compiler/scala/tools/nsc/transform/UnCurry.scala
index 8ae9490dbe..65b9eb79b3 100644
--- a/src/compiler/scala/tools/nsc/transform/UnCurry.scala
+++ b/src/compiler/scala/tools/nsc/transform/UnCurry.scala
@@ -61,24 +61,6 @@ abstract class UnCurry extends InfoTransform
 
 // uncurry and uncurryType expand type aliases
 
-  /** Traverse tree omitting local method definitions.
-   *  If a `return` is encountered, set `returnFound` to true.
-   *  Used for MSIL only.
-   */
-  private object lookForReturns extends Traverser {
-    var returnFound = false
-    override def traverse(tree: Tree): Unit =  tree match {
-      case Return(_) => returnFound = true
-      case DefDef(_, _, _, _, _, _) => ;
-      case _ => super.traverse(tree)
-    }
-    def found(tree: Tree) = {
-      returnFound = false
-      traverse(tree)
-      returnFound
-    }
-  }
-
   class UnCurryTransformer(unit: CompilationUnit) extends TypingTransformer(unit) {
     private var needTryLift       = false
     private var inPattern         = false
@@ -537,13 +519,6 @@ abstract class UnCurry extends InfoTransform
         finally needTryLift = saved
       }
 
-      /** A try or synchronized needs to be lifted anyway for MSIL if it contains
-       *  return statements. These are disallowed in the CLR. By lifting
-       *  such returns will be converted to throws.
-       */
-      def shouldBeLiftedAnyway(tree: Tree) = false && // buggy, see #1981
-        forMSIL && lookForReturns.found(tree)
-
       /** Transform tree `t` to { def f = t; f } where `f` is a fresh name
        */
       def liftTree(tree: Tree) = {
@@ -618,13 +593,10 @@ abstract class UnCurry extends InfoTransform
             treeCopy.UnApply(tree, fn1, args1)
 
           case Apply(fn, args) =>
-            if (fn.symbol == Object_synchronized && shouldBeLiftedAnyway(args.head))
-              transform(treeCopy.Apply(tree, fn, List(liftTree(args.head))))
-            else
-              withNeedLift(true) {
-                val formals = fn.tpe.paramTypes
-                treeCopy.Apply(tree, transform(fn), transformTrees(transformArgs(tree.pos, fn.symbol, args, formals)))
-              }
+            withNeedLift(true) {
+              val formals = fn.tpe.paramTypes
+              treeCopy.Apply(tree, transform(fn), transformTrees(transformArgs(tree.pos, fn.symbol, args, formals)))
+            }
 
           case Assign(_: RefTree, _) =>
             withNeedLift(true) { super.transform(tree) }
@@ -643,7 +615,7 @@ abstract class UnCurry extends InfoTransform
             super.transform(tree)
 
           case Try(block, catches, finalizer) =>
-            if (needTryLift || shouldBeLiftedAnyway(tree)) transform(liftTree(tree))
+            if (needTryLift) transform(liftTree(tree))
             else super.transform(tree)
 
           case CaseDef(pat, guard, body) =>
diff --git a/src/compiler/scala/tools/nsc/typechecker/Macros.scala b/src/compiler/scala/tools/nsc/typechecker/Macros.scala
index e40d978e6d..f595aa7dc7 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Macros.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Macros.scala
@@ -470,9 +470,6 @@ trait Macros extends scala.tools.reflect.FastTrack with Traces {
    *  Is also capable of detecting REPL and reusing its classloader.
    */
   lazy val macroClassloader: ClassLoader = {
-    if (global.forMSIL)
-      throw new UnsupportedOperationException("Scala reflection not available on this platform")
-
     val classpath = global.classPath.asURLs
     macroLogVerbose("macro classloader: initializing from -cp: %s".format(classpath))
     val loader = ScalaClassLoader.fromURLs(classpath, self.getClass.getClassLoader)
diff --git a/src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala b/src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala
index 3ac5d388d3..8e2a1fc5dc 100644
--- a/src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala
@@ -201,8 +201,7 @@ trait MethodSynthesis {
     )
     def beanAccessors(vd: ValDef): List[DerivedFromValDef] = {
       val setter = if (vd.mods.isMutable) List(BeanSetter(vd)) else Nil
-      if (forMSIL) Nil
-      else if (vd.symbol hasAnnotation BeanPropertyAttr)
+      if (vd.symbol hasAnnotation BeanPropertyAttr)
         BeanGetter(vd) :: setter
       else if (vd.symbol hasAnnotation BooleanBeanPropertyAttr)
         BooleanBeanGetter(vd) :: setter
@@ -521,9 +520,6 @@ trait MethodSynthesis {
     }
 
     protected def enterBeans(tree: ValDef) {
-      if (forMSIL)
-        return
-
       val ValDef(mods, name, _, _) = tree
       val beans = beanAccessorsFromNames(tree)
       if (beans.nonEmpty) {
diff --git a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala
index 0ae225ccee..16680c3f13 100644
--- a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala
@@ -1116,8 +1116,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans
         def isUnit(s: Symbol)    = unboxedValueClass(s) == UnitClass
         def isNumeric(s: Symbol) = isNumericValueClass(unboxedValueClass(s)) || isAnyNumber(s)
         def isScalaNumber(s: Symbol) = s isSubClass ScalaNumberClass
-        // test is behind a platform guard
-        def isJavaNumber(s: Symbol) = !forMSIL && (s isSubClass JavaNumberClass)
+        def isJavaNumber(s: Symbol) = s isSubClass JavaNumberClass
         // includes java.lang.Number if appropriate [SI-5779]
         def isAnyNumber(s: Symbol) = isScalaNumber(s) || isJavaNumber(s)
         def isMaybeAnyValue(s: Symbol) = isPrimitiveValueClass(unboxedValueClass(s)) || isMaybeValue(s)
@@ -1160,7 +1159,7 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans
             nonSensiblyNeq()
         }
         else if (isNumeric(receiver)) {
-          if (!isNumeric(actual) && !forMSIL)
+          if (!isNumeric(actual))
             if (isUnit(actual) || isBoolean(actual) || !isMaybeValue(actual))   // 5 == "abc"
               nonSensiblyNeq()
         }
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index e534e36a0d..8d606a8fd5 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -1130,13 +1130,6 @@ trait Typers extends Modes with Adaptations with Tags {
                     // (14); the condition prevents chains of views
                     debuglog("inferring view from " + tree.tpe + " to " + pt)
                     val coercion = inferView(tree, tree.tpe, pt, true)
-                    // convert forward views of delegate types into closures wrapped around
-                    // the delegate's apply method (the "Invoke" method, which was translated into apply)
-                    if (forMSIL && coercion != null && isCorrespondingDelegate(tree.tpe, pt)) {
-                      val meth: Symbol = tree.tpe.member(nme.apply)
-                      debuglog("replacing forward delegate view with: " + meth + ":" + meth.tpe)
-                      return typed(Select(tree, meth), mode, pt)
-                    }
                     if (coercion != EmptyTree) {
                       def msg = "inferred view from " + tree.tpe + " to " + pt + " = " + coercion + ":" + coercion.tpe
                       if (settings.logImplicitConv.value)
@@ -3037,26 +3030,6 @@ trait Typers extends Modes with Adaptations with Tags {
                   case _ => tp
                 }
 
-                // Replace the Delegate-Chainer methods += and -= with corresponding
-                // + and - calls, which are translated in the code generator into
-                // Combine and Remove
-                if (forMSIL) {
-                  fun match {
-                    case Select(qual, name) =>
-                      if (isSubType(qual.tpe, DelegateClass.tpe)
-                        && (name == encode("+=") || name == encode("-="))) {
-                        val n = if (name == encode("+=")) nme.PLUS else nme.MINUS
-                        val f = Select(qual, n)
-                        // the compiler thinks, the PLUS method takes only one argument,
-                        // but he thinks it's an instance method -> still two ref's on the stack
-                        //  -> translated by backend
-                        val rhs = treeCopy.Apply(tree, f, args)
-                        return typed(Assign(qual, rhs))
-                      }
-                    case _ => ()
-                  }
-                }
-
                 /**
                  * This is translating uses of List() into Nil.  This is less
                  *  than ideal from a consistency standpoint, but it shouldn't be
@@ -4162,24 +4135,7 @@ trait Typers extends Modes with Adaptations with Tags {
           else adapt(expr1, mode, functionType(formals map (t => WildcardType), WildcardType))
         case MethodType(formals, _) =>
           if (isFunctionType(pt)) expr1
-          else expr1 match {
-            case Select(qual, name) if (forMSIL &&
-                                        pt != WildcardType &&
-                                        pt != ErrorType &&
-                                        isSubType(pt, DelegateClass.tpe)) =>
-              val scalaCaller = newScalaCaller(pt)
-              addScalaCallerInfo(scalaCaller, expr1.symbol)
-              val n: Name = scalaCaller.name
-              val del = Ident(DelegateClass) setType DelegateClass.tpe
-              val f = Select(del, n)
-              //val f1 = TypeApply(f, List(Ident(pt.symbol) setType pt))
-              val args: List[Tree] = if(expr1.symbol.isStatic) List(Literal(Constant(null)))
-                                     else List(qual) // where the scala-method is located
-              val rhs = Apply(f, args)
-              typed(rhs)
-            case _ =>
-              adapt(expr1, mode, functionType(formals map (t => WildcardType), WildcardType))
-          }
+          else adapt(expr1, mode, functionType(formals map (t => WildcardType), WildcardType))
         case ErrorType =>
           expr1
         case _ =>
diff --git a/src/compiler/scala/tools/nsc/util/ClassPath.scala b/src/compiler/scala/tools/nsc/util/ClassPath.scala
index ee66801c45..cbf6ef69d7 100644
--- a/src/compiler/scala/tools/nsc/util/ClassPath.scala
+++ b/src/compiler/scala/tools/nsc/util/ClassPath.scala
@@ -184,8 +184,7 @@ abstract class ClassPath[T] {
   def sourcepaths: IndexedSeq[AbstractFile]
 
   /**
-   * Represents classes which can be loaded with a ClassfileLoader/MsilFileLoader
-   * and / or a SourcefileLoader.
+   * Represents classes which can be loaded with a ClassfileLoader and/or SourcefileLoader.
    */
   case class ClassRep(binary: Option[T], source: Option[AbstractFile]) {
     def name: String = binary match {
diff --git a/src/compiler/scala/tools/nsc/util/MsilClassPath.scala b/src/compiler/scala/tools/nsc/util/MsilClassPath.scala
deleted file mode 100644
index 2f209c550d..0000000000
--- a/src/compiler/scala/tools/nsc/util/MsilClassPath.scala
+++ /dev/null
@@ -1,166 +0,0 @@
-/* NSC -- new Scala compiler
- * Copyright 2006-2013 LAMP/EPFL
- * @author  Martin Odersky
- */
-
-// $Id$
-
-package scala.tools.nsc
-package util
-
-import scala.util.Sorting
-import scala.collection.mutable
-import scala.tools.nsc.io.{ AbstractFile, MsilFile }
-import ch.epfl.lamp.compiler.msil.{ Type => MSILType, Assembly }
-import ClassPath.{ ClassPathContext, isTraitImplementation }
-
-/** Keeping the MSIL classpath code in its own file is important to make sure
- *  we don't accidentally introduce a dependency on msil.jar in the jvm.
- */
-
-object MsilClassPath {
-  def collectTypes(assemFile: AbstractFile) = {
-    var res: Array[MSILType] = MSILType.EmptyTypes
-    val assem = Assembly.LoadFrom(assemFile.path)
-    if (assem != null) {
-      // DeclaringType == null: true for non-inner classes
-      res = assem.GetTypes() filter (_.DeclaringType == null)
-      Sorting.stableSort(res, (t1: MSILType, t2: MSILType) => (t1.FullName compareTo t2.FullName) < 0)
-    }
-    res
-  }
-
-  /** On the java side this logic is in PathResolver, but as I'm not really
-   *  up to folding MSIL into that, I am encapsulating it here.
-   */
-  def fromSettings(settings: Settings): MsilClassPath = {
-    val context =
-      if (settings.inline.value) new MsilContext
-      else new MsilContext { override def isValidName(name: String) = !isTraitImplementation(name) }
-
-    import settings._
-    new MsilClassPath(assemextdirs.value, assemrefs.value, sourcepath.value, context)
-  }
-
-  class MsilContext extends ClassPathContext[MsilFile] {
-    def toBinaryName(rep: MsilFile) = rep.msilType.Name
-    def newClassPath(assemFile: AbstractFile) = new AssemblyClassPath(MsilClassPath collectTypes assemFile, "", this)
-  }
-
-  private def assembleEntries(ext: String, user: String, source: String, context: MsilContext): List[ClassPath[MsilFile]] = {
-    import ClassPath._
-    val etr = new mutable.ListBuffer[ClassPath[MsilFile]]
-    val names = new mutable.HashSet[String]
-
-    // 1. Assemblies from -Xassem-extdirs
-    for (dirName <- expandPath(ext, expandStar = false)) {
-      val dir = AbstractFile.getDirectory(dirName)
-      if (dir ne null) {
-        for (file <- dir) {
-          val name = file.name.toLowerCase
-          if (name.endsWith(".dll") || name.endsWith(".exe")) {
-            names += name
-            etr += context.newClassPath(file)
-          }
-        }
-      }
-    }
-
-    // 2. Assemblies from -Xassem-path
-    for (fileName <- expandPath(user, expandStar = false)) {
-      val file = AbstractFile.getFile(fileName)
-      if (file ne null) {
-        val name = file.name.toLowerCase
-        if (name.endsWith(".dll") || name.endsWith(".exe")) {
-          names += name
-          etr += context.newClassPath(file)
-        }
-      }
-    }
-
-    def check(n: String) {
-      if (!names.contains(n))
-      throw new AssertionError("Cannot find assembly "+ n +
-         ". Use -Xassem-extdirs or -Xassem-path to specify its location")
-    }
-    check("mscorlib.dll")
-    check("scalaruntime.dll")
-
-    // 3. Source path
-    for (dirName <- expandPath(source, expandStar = false)) {
-      val file = AbstractFile.getDirectory(dirName)
-      if (file ne null) etr += new SourcePath[MsilFile](file, context)
-    }
-
-    etr.toList
-  }
-}
-import MsilClassPath._
-
-/**
- * A assembly file (dll / exe) containing classes and namespaces
- */
-class AssemblyClassPath(types: Array[MSILType], namespace: String, val context: MsilContext) extends ClassPath[MsilFile] {
-  def name = {
-    val i = namespace.lastIndexOf('.')
-    if (i < 0) namespace
-    else namespace drop (i + 1)
-  }
-  def asURLs = List(new java.net.URL(name))
-  def asClasspathString = sys.error("Unknown")  // I don't know what if anything makes sense here?
-
-  private lazy val first: Int = {
-    var m = 0
-    var n = types.length - 1
-    while (m < n) {
-      val l = (m + n) / 2
-      val res = types(l).FullName.compareTo(namespace)
-      if (res < 0) m = l + 1
-      else n = l
-    }
-    if (types(m).FullName.startsWith(namespace)) m else types.length
-  }
-
-  lazy val classes = {
-    val cls = new mutable.ListBuffer[ClassRep]
-    var i = first
-    while (i < types.length && types(i).Namespace.startsWith(namespace)) {
-      // CLRTypes used to exclude java.lang.Object and java.lang.String (no idea why..)
-      if (types(i).Namespace == namespace)
-        cls += ClassRep(Some(new MsilFile(types(i))), None)
-      i += 1
-    }
-    cls.toIndexedSeq
-  }
-
-  lazy val packages = {
-    val nsSet = new mutable.HashSet[String]
-    var i = first
-    while (i < types.length && types(i).Namespace.startsWith(namespace)) {
-      val subns = types(i).Namespace
-      if (subns.length > namespace.length) {
-        // example: namespace = "System", subns = "System.Reflection.Emit"
-        //   => find second "." and "System.Reflection" to nsSet.
-        val end = subns.indexOf('.', namespace.length + 1)
-        nsSet += (if (end < 0) subns
-                  else subns.substring(0, end))
-      }
-      i += 1
-    }
-    val xs = for (ns <- nsSet.toList)
-      yield new AssemblyClassPath(types, ns, context)
-
-    xs.toIndexedSeq
-  }
-
-  val sourcepaths: IndexedSeq[AbstractFile] = IndexedSeq()
-
-  override def toString() = "assembly classpath "+ namespace
-}
-
-/**
- * The classpath when compiling with target:msil. Binary files are represented as
- * MSILType values.
- */
-class MsilClassPath(ext: String, user: String, source: String, context: MsilContext)
-extends MergedClassPath[MsilFile](MsilClassPath.assembleEntries(ext, user, source, context), context) { }