Merge pull request #4312 from lrytz/opt/inlining

Inliner for GenBCode

23 files changed, 2007 insertions, 377 deletions

diff --git a/src/asm/scala/tools/asm/tree/MethodInsnNode.java b/src/asm/scala/tools/asm/tree/MethodInsnNode.java
index 1ec46d473d..30c7854646 100644
--- a/src/asm/scala/tools/asm/tree/MethodInsnNode.java
+++ b/src/asm/scala/tools/asm/tree/MethodInsnNode.java
@@ -45,6 +45,7 @@ public class MethodInsnNode extends AbstractInsnNode {
     /**
      * The internal name of the method's owner class (see
      * {@link scala.tools.asm.Type#getInternalName() getInternalName}).
+     * For methods of arrays, e.g., clone(), the array type descriptor.
      */
     public String owner;
 
diff --git a/src/compiler/scala/tools/nsc/Reporting.scala b/src/compiler/scala/tools/nsc/Reporting.scala
index 4d7e9e753f..72a4b69536 100644
--- a/src/compiler/scala/tools/nsc/Reporting.scala
+++ b/src/compiler/scala/tools/nsc/Reporting.scala
@@ -26,7 +26,7 @@ trait Reporting extends scala.reflect.internal.Reporting { self: ast.Positions w
   protected def PerRunReporting = new PerRunReporting
   class PerRunReporting extends PerRunReportingBase {
     /** Collects for certain classes of warnings during this run. */
-    private class ConditionalWarning(what: String, option: Settings#BooleanSetting) {
+    private class ConditionalWarning(what: String, option: Settings#BooleanSetting)(reRunFlag: String = option.name) {
       val warnings = mutable.LinkedHashMap[Position, String]()
       def warn(pos: Position, msg: String) =
         if (option) reporter.warning(pos, msg)
@@ -37,16 +37,16 @@ trait Reporting extends scala.reflect.internal.Reporting { self: ast.Positions w
           val warningVerb  = if (numWarnings == 1) "was" else "were"
           val warningCount = countElementsAsString(numWarnings, s"$what warning")
 
-          reporter.warning(NoPosition, s"there $warningVerb $warningCount; re-run with ${option.name} for details")
+          reporter.warning(NoPosition, s"there $warningVerb $warningCount; re-run with $reRunFlag for details")
         }
     }
 
     // This change broke sbt; I gave it the thrilling name of uncheckedWarnings0 so
     // as to recover uncheckedWarnings for its ever-fragile compiler interface.
-    private val _deprecationWarnings    = new ConditionalWarning("deprecation", settings.deprecation)
-    private val _uncheckedWarnings      = new ConditionalWarning("unchecked", settings.unchecked)
-    private val _featureWarnings        = new ConditionalWarning("feature", settings.feature)
-    private val _inlinerWarnings        = new ConditionalWarning("inliner", settings.YinlinerWarnings)
+    private val _deprecationWarnings    = new ConditionalWarning("deprecation", settings.deprecation)()
+    private val _uncheckedWarnings      = new ConditionalWarning("unchecked", settings.unchecked)()
+    private val _featureWarnings        = new ConditionalWarning("feature", settings.feature)()
+    private val _inlinerWarnings        = new ConditionalWarning("inliner", settings.YinlinerWarnings)(if (settings.isBCodeAskedFor) settings.YoptWarnings.name else settings.YinlinerWarnings.name)
     private val _allConditionalWarnings = List(_deprecationWarnings, _uncheckedWarnings, _featureWarnings, _inlinerWarnings)
 
     // TODO: remove in favor of the overload that takes a Symbol, give that argument a default (NoSymbol)
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/AsmUtils.scala b/src/compiler/scala/tools/nsc/backend/jvm/AsmUtils.scala
index d3f09217cd..0df1b2029d 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/AsmUtils.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/AsmUtils.scala
@@ -7,8 +7,8 @@ package scala.tools.nsc.backend.jvm
 
 import scala.tools.asm.tree.{InsnList, AbstractInsnNode, ClassNode, MethodNode}
 import java.io.{StringWriter, PrintWriter}
-import scala.tools.asm.util.{TraceClassVisitor, TraceMethodVisitor, Textifier}
-import scala.tools.asm.{Attribute, ClassReader}
+import scala.tools.asm.util.{CheckClassAdapter, TraceClassVisitor, TraceMethodVisitor, Textifier}
+import scala.tools.asm.{ClassWriter, Attribute, ClassReader}
 import scala.collection.convert.decorateAsScala._
 import scala.tools.nsc.backend.jvm.opt.InlineInfoAttributePrototype
 
@@ -106,4 +106,18 @@ object AsmUtils {
    * Returns a human-readable representation of the given instruction sequence.
    */
   def textify(insns: InsnList): String = textify(insns.iterator().asScala)
+
+  /**
+   * Run ASM's CheckClassAdapter over a class. Returns None if no problem is found, otherwise
+   * Some(msg) with the verifier's error message.
+   */
+  def checkClass(classNode: ClassNode): Option[String] = {
+    val cw = new ClassWriter(ClassWriter.COMPUTE_MAXS)
+    classNode.accept(cw)
+    val sw = new StringWriter()
+    val pw = new PrintWriter(sw)
+    CheckClassAdapter.verify(new ClassReader(cw.toByteArray), false, pw)
+    val res = sw.toString
+    if (res.isEmpty) None else Some(res)
+  }
 }
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeAsmCommon.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeAsmCommon.scala
index 2ebf338f5e..162da4236a 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeAsmCommon.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeAsmCommon.scala
@@ -7,7 +7,8 @@ package scala.tools.nsc
 package backend.jvm
 
 import scala.tools.nsc.Global
-import scala.tools.nsc.backend.jvm.BTypes.{MethodInlineInfo, InlineInfo, InternalName}
+import scala.tools.nsc.backend.jvm.BTypes.{InternalName, MethodInlineInfo, InlineInfo}
+import BackendReporting.ClassSymbolInfoFailureSI9111
 
 /**
  * This trait contains code shared between GenBCode and GenASM that depends on types defined in
@@ -336,7 +337,7 @@ final class BCodeAsmCommon[G <: Global](val global: G) {
 
     val isEffectivelyFinal = classSym.isEffectivelyFinal
 
-    var warning = Option.empty[String]
+    var warning = Option.empty[ClassSymbolInfoFailureSI9111]
 
     // Primitive methods cannot be inlined, so there's no point in building a MethodInlineInfo. Also, some
     // primitive methods (e.g., `isInstanceOf`) have non-erased types, which confuses [[typeToBType]].
@@ -345,7 +346,7 @@ final class BCodeAsmCommon[G <: Global](val global: G) {
         if (completeSilentlyAndCheckErroneous(methodSym)) {
           // Happens due to SI-9111. Just don't provide any MethodInlineInfo for that method, we don't need fail the compiler.
           if (!classSym.isJavaDefined) devWarning("SI-9111 should only be possible for Java classes")
-          warning = Some(s"Failed to get the type of a method of class symbol ${classSym.fullName} due to SI-9111")
+          warning = Some(ClassSymbolInfoFailureSI9111(classSym.fullName))
           None
         } else {
           val name      = methodSym.javaSimpleName.toString // same as in genDefDef
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala
index 062daa4eac..15b014bdd3 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeBodyBuilder.scala
@@ -12,6 +12,8 @@ package jvm
 import scala.annotation.switch
 
 import scala.tools.asm
+import GenBCode._
+import BackendReporting._
 
 /*
  *
@@ -92,7 +94,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
       val thrownKind = tpeTK(expr)
       // `throw null` is valid although scala.Null (as defined in src/libray-aux) isn't a subtype of Throwable.
       // Similarly for scala.Nothing (again, as defined in src/libray-aux).
-      assert(thrownKind.isNullType || thrownKind.isNothingType || thrownKind.asClassBType.isSubtypeOf(ThrowableReference))
+      assert(thrownKind.isNullType || thrownKind.isNothingType || thrownKind.asClassBType.isSubtypeOf(ThrowableReference).get)
       genLoad(expr, thrownKind)
       lineNumber(expr)
       emit(asm.Opcodes.ATHROW) // ICode enters here into enterIgnoreMode, we'll rely instead on DCE at ClassNode level.
@@ -229,7 +231,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
 
       if (isArithmeticOp(code))                genArithmeticOp(tree, code)
       else if (code == scalaPrimitives.CONCAT) genStringConcat(tree)
-      else if (code == scalaPrimitives.HASH)   genScalaHash(receiver)
+      else if (code == scalaPrimitives.HASH)   genScalaHash(receiver, tree.pos)
       else if (isArrayOp(code))                genArrayOp(tree, code, expectedType)
       else if (isLogicalOp(code) || isComparisonOp(code)) {
         val success, failure, after = new asm.Label
@@ -583,7 +585,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
           // if (fun.symbol.isConstructor) Static(true) else SuperCall(mix);
           mnode.visitVarInsn(asm.Opcodes.ALOAD, 0)
           genLoadArguments(args, paramTKs(app))
-          genCallMethod(fun.symbol, invokeStyle, pos = app.pos)
+          genCallMethod(fun.symbol, invokeStyle, app.pos)
           generatedType = asmMethodType(fun.symbol).returnType
 
         // 'new' constructor call: Note: since constructors are
@@ -613,7 +615,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
                  */
                 for (i <- args.length until dims) elemKind = ArrayBType(elemKind)
               }
-              (argsSize : @switch) match {
+              argsSize match {
                 case 1 => bc newarray elemKind
                 case _ =>
                   val descr = ('[' * argsSize) + elemKind.descriptor // denotes the same as: arrayN(elemKind, argsSize).descriptor
@@ -625,7 +627,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
               mnode.visitTypeInsn(asm.Opcodes.NEW, rt.internalName)
               bc dup generatedType
               genLoadArguments(args, paramTKs(app))
-              genCallMethod(ctor, icodes.opcodes.Static(onInstance = true))
+              genCallMethod(ctor, icodes.opcodes.Static(onInstance = true), app.pos)
 
             case _ =>
               abort(s"Cannot instantiate $tpt of kind: $generatedType")
@@ -635,7 +637,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
           val nativeKind = tpeTK(expr)
           genLoad(expr, nativeKind)
           val MethodNameAndType(mname, methodType) = asmBoxTo(nativeKind)
-          bc.invokestatic(BoxesRunTime.internalName, mname, methodType.descriptor)
+          bc.invokestatic(BoxesRunTime.internalName, mname, methodType.descriptor, app.pos)
           generatedType = boxResultType(fun.symbol) // was toTypeKind(fun.symbol.tpe.resultType)
 
         case Apply(fun @ _, List(expr)) if currentRun.runDefinitions.isUnbox(fun.symbol) =>
@@ -643,7 +645,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
           val boxType = unboxResultType(fun.symbol) // was toTypeKind(fun.symbol.owner.linkedClassOfClass.tpe)
           generatedType = boxType
           val MethodNameAndType(mname, methodType) = asmUnboxTo(boxType)
-          bc.invokestatic(BoxesRunTime.internalName, mname, methodType.descriptor)
+          bc.invokestatic(BoxesRunTime.internalName, mname, methodType.descriptor, app.pos)
 
         case app @ Apply(fun, args) =>
           val sym = fun.symbol
@@ -694,10 +696,10 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
                 // descriptor (instead of a class internal name):
                 //   invokevirtual  #2; //Method "[I".clone:()Ljava/lang/Object
                 val target: String = targetTypeKind.asRefBType.classOrArrayType
-                bc.invokevirtual(target, "clone", "()Ljava/lang/Object;")
+                bc.invokevirtual(target, "clone", "()Ljava/lang/Object;", app.pos)
               }
               else {
-                genCallMethod(sym, invokeStyle, hostClass, app.pos)
+                genCallMethod(sym, invokeStyle, app.pos, hostClass)
               }
 
             } // end of genNormalMethodCall()
@@ -809,7 +811,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
     }
 
     def adapt(from: BType, to: BType) {
-      if (!from.conformsTo(to)) {
+      if (!from.conformsTo(to).get) {
         to match {
           case UNIT => bc drop from
           case _    => bc.emitT2T(from, to)
@@ -975,23 +977,23 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
         // Optimization for expressions of the form "" + x.  We can avoid the StringBuilder.
         case List(Literal(Constant("")), arg) =>
           genLoad(arg, ObjectReference)
-          genCallMethod(String_valueOf, icodes.opcodes.Static(onInstance = false))
+          genCallMethod(String_valueOf, icodes.opcodes.Static(onInstance = false), arg.pos)
 
         case concatenations =>
-          bc.genStartConcat
+          bc.genStartConcat(tree.pos)
           for (elem <- concatenations) {
             val kind = tpeTK(elem)
             genLoad(elem, kind)
-            bc.genStringConcat(kind)
+            bc.genStringConcat(kind, elem.pos)
           }
-          bc.genEndConcat
+          bc.genEndConcat(tree.pos)
 
       }
 
       StringReference
     }
 
-    def genCallMethod(method: Symbol, style: InvokeStyle, hostClass0: Symbol = null, pos: Position = NoPosition) {
+    def genCallMethod(method: Symbol, style: InvokeStyle, pos: Position, hostClass0: Symbol = null) {
 
       val siteSymbol = claszSymbol
       val hostSymbol = if (hostClass0 == null) method.owner else hostClass0
@@ -1035,26 +1037,26 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
       }
 
       if (style.isStatic) {
-        if (style.hasInstance) { bc.invokespecial  (jowner, jname, mdescr) }
-        else                   { bc.invokestatic   (jowner, jname, mdescr) }
+        if (style.hasInstance) { bc.invokespecial  (jowner, jname, mdescr, pos) }
+        else                   { bc.invokestatic   (jowner, jname, mdescr, pos) }
       }
       else if (style.isDynamic) {
-        if (needsInterfaceCall(receiver)) { bc.invokeinterface(jowner, jname, mdescr) }
-        else                              { bc.invokevirtual  (jowner, jname, mdescr) }
+        if (needsInterfaceCall(receiver)) { bc.invokeinterface(jowner, jname, mdescr, pos) }
+        else                              { bc.invokevirtual  (jowner, jname, mdescr, pos) }
       }
       else {
         assert(style.isSuper, s"An unknown InvokeStyle: $style")
-        bc.invokespecial(jowner, jname, mdescr)
+        bc.invokespecial(jowner, jname, mdescr, pos)
         initModule()
       }
 
     } // end of genCallMethod()
 
     /* Generate the scala ## method. */
-    def genScalaHash(tree: Tree): BType = {
+    def genScalaHash(tree: Tree, applyPos: Position): BType = {
       genLoadModule(ScalaRunTimeModule) // TODO why load ScalaRunTimeModule if ## has InvokeStyle of Static(false) ?
       genLoad(tree, ObjectReference)
-      genCallMethod(hashMethodSym, icodes.opcodes.Static(onInstance = false))
+      genCallMethod(hashMethodSym, icodes.opcodes.Static(onInstance = false), applyPos)
 
       INT
     }
@@ -1186,8 +1188,8 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
               // TODO !!!!!!!!!! isReferenceType, in the sense of TypeKind? (ie non-array, non-boxed, non-nothing, may be null)
               if (scalaPrimitives.isUniversalEqualityOp(code) && tpeTK(lhs).isClass) {
                 // `lhs` has reference type
-                if (code == EQ) genEqEqPrimitive(lhs, rhs, success, failure)
-                else            genEqEqPrimitive(lhs, rhs, failure, success)
+                if (code == EQ) genEqEqPrimitive(lhs, rhs, success, failure, tree.pos)
+                else            genEqEqPrimitive(lhs, rhs, failure, success, tree.pos)
               }
               else if (scalaPrimitives.isComparisonOp(code))
                 genComparisonOp(lhs, rhs, code)
@@ -1207,7 +1209,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
      * @param l       left-hand-side  of the '=='
      * @param r       right-hand-side of the '=='
      */
-    def genEqEqPrimitive(l: Tree, r: Tree, success: asm.Label, failure: asm.Label) {
+    def genEqEqPrimitive(l: Tree, r: Tree, success: asm.Label, failure: asm.Label, pos: Position) {
 
       /* True if the equality comparison is between values that require the use of the rich equality
        * comparator (scala.runtime.Comparator.equals). This is the case when either side of the
@@ -1231,7 +1233,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
         }
         genLoad(l, ObjectReference)
         genLoad(r, ObjectReference)
-        genCallMethod(equalsMethod, icodes.opcodes.Static(onInstance = false))
+        genCallMethod(equalsMethod, icodes.opcodes.Static(onInstance = false), pos)
         genCZJUMP(success, failure, icodes.NE, BOOL)
       }
       else {
@@ -1247,7 +1249,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
           // SI-7852 Avoid null check if L is statically non-null.
           genLoad(l, ObjectReference)
           genLoad(r, ObjectReference)
-          genCallMethod(Object_equals, icodes.opcodes.Dynamic)
+          genCallMethod(Object_equals, icodes.opcodes.Dynamic, pos)
           genCZJUMP(success, failure, icodes.NE, BOOL)
         } else {
           // l == r -> if (l eq null) r eq null else l.equals(r)
@@ -1268,7 +1270,7 @@ abstract class BCodeBodyBuilder extends BCodeSkelBuilder {
 
           markProgramPoint(lNonNull)
           locals.load(eqEqTempLocal)
-          genCallMethod(Object_equals, icodes.opcodes.Dynamic)
+          genCallMethod(Object_equals, icodes.opcodes.Dynamic, pos)
           genCZJUMP(success, failure, icodes.NE, BOOL)
         }
       }
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala
index ccee230191..3b7dbc18da 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala
@@ -10,6 +10,8 @@ package backend.jvm
 import scala.tools.asm
 import scala.collection.mutable
 import scala.tools.nsc.io.AbstractFile
+import GenBCode._
+import BackendReporting._
 
 /*
  *  Traits encapsulating functionality to convert Scala AST Trees into ASM ClassNodes.
@@ -66,7 +68,7 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
     override def getCommonSuperClass(inameA: String, inameB: String): String = {
       val a = classBTypeFromInternalName(inameA)
       val b = classBTypeFromInternalName(inameB)
-      val lub = a.jvmWiseLUB(b)
+      val lub = a.jvmWiseLUB(b).get
       val lubName = lub.internalName
       assert(lubName != "scala/Any")
       lubName // ASM caches the answer during the lifetime of a ClassWriter. We outlive that. Not sure whether caching on our side would improve things.
@@ -204,12 +206,12 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
    * can-multi-thread
    */
   final def addInnerClassesASM(jclass: asm.ClassVisitor, refedInnerClasses: List[ClassBType]) {
-    val allNestedClasses = refedInnerClasses.flatMap(_.enclosingNestedClassesChain).distinct
+    val allNestedClasses = refedInnerClasses.flatMap(_.enclosingNestedClassesChain.get).distinct
 
     // sorting ensures nested classes are listed after their enclosing class thus satisfying the Eclipse Java compiler
     for (nestedClass <- allNestedClasses.sortBy(_.internalName.toString)) {
       // Extract the innerClassEntry - we know it exists, enclosingNestedClassesChain only returns nested classes.
-      val Some(e) = nestedClass.innerClassAttributeEntry
+      val Some(e) = nestedClass.innerClassAttributeEntry.get
       jclass.visitInnerClass(e.name, e.outerName, e.innerName, e.flags)
     }
   }
@@ -331,125 +333,42 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
       getClassBTypeAndRegisterInnerClass(classSym).internalName
     }
 
-    private def assertClassNotArray(sym: Symbol): Unit = {
-      assert(sym.isClass, sym)
-      assert(sym != definitions.ArrayClass || isCompilingArray, sym)
-    }
-
-    private def assertClassNotArrayNotPrimitive(sym: Symbol): Unit = {
-      assertClassNotArray(sym)
-      assert(!primitiveTypeMap.contains(sym) || isCompilingPrimitive, sym)
-    }
-
     /**
      * The ClassBType for a class symbol. If the class is nested, the ClassBType is added to the
      * innerClassBufferASM.
      *
-     * The class symbol scala.Nothing is mapped to the class scala.runtime.Nothing$. Similarly,
-     * scala.Null is mapped to scala.runtime.Null$. This is because there exist no class files
-     * for the Nothing / Null. If used for example as a parameter type, we use the runtime classes
-     * in the classfile method signature.
-     *
-     * Note that the referenced class symbol may be an implementation class. For example when
-     * compiling a mixed-in method that forwards to the static method in the implementation class,
-     * the class descriptor of the receiver (the implementation class) is obtained by creating the
-     * ClassBType.
+     * TODO: clean up the way we track referenced inner classes.
+     * doing it during code generation is not correct when the optimizer changes the code.
      */
     final def getClassBTypeAndRegisterInnerClass(sym: Symbol): ClassBType = {
-      assertClassNotArrayNotPrimitive(sym)
-
-      if (sym == definitions.NothingClass) RT_NOTHING
-      else if (sym == definitions.NullClass) RT_NULL
-      else {
-       val r = classBTypeFromSymbol(sym)
-       if (r.isNestedClass) innerClassBufferASM += r
-       r
-      }
+      val r = classBTypeFromSymbol(sym)
+      if (r.isNestedClass.get) innerClassBufferASM += r
+      r
     }
 
     /**
-     * This method returns the BType for a type reference, for example a parameter type.
-     *
-     * If the result is a ClassBType for a nested class, it is added to the innerClassBufferASM.
-     *
-     * If `t` references a class, toTypeKind ensures that the class is not an implementation class.
-     * See also comment on getClassBTypeAndRegisterInnerClass, which is invoked for implementation
-     * classes.
+     * The BType for a type reference. If the result is a ClassBType for a nested class, it is added
+     * to the innerClassBufferASM.
+     * TODO: clean up the way we track referenced inner classes.
      */
-    final def toTypeKind(t: Type): BType = {
-      import definitions.ArrayClass
-
-      /**
-       * Primitive types are represented as TypeRefs to the class symbol of, for example, scala.Int.
-       * The `primitiveTypeMap` maps those class symbols to the corresponding PrimitiveBType.
-       */
-      def primitiveOrClassToBType(sym: Symbol): BType = {
-        assertClassNotArray(sym)
-        assert(!sym.isImplClass, sym)
-        primitiveTypeMap.getOrElse(sym, getClassBTypeAndRegisterInnerClass(sym))
-      }
-
-      /**
-       * When compiling Array.scala, the type parameter T is not erased and shows up in method
-       * signatures, e.g. `def apply(i: Int): T`. A TyperRef to T is replaced by ObjectReference.
-       */
-      def nonClassTypeRefToBType(sym: Symbol): ClassBType = {
-        assert(sym.isType && isCompilingArray, sym)
-        ObjectReference
-      }
-
-      t.dealiasWiden match {
-        case TypeRef(_, ArrayClass, List(arg))  => ArrayBType(toTypeKind(arg))  // Array type such as Array[Int] (kept by erasure)
-        case TypeRef(_, sym, _) if !sym.isClass => nonClassTypeRefToBType(sym)  // See comment on nonClassTypeRefToBType
-        case TypeRef(_, sym, _)                 => primitiveOrClassToBType(sym) // Common reference to a type such as scala.Int or java.lang.String
-        case ClassInfoType(_, _, sym)           => primitiveOrClassToBType(sym) // We get here, for example, for genLoadModule, which invokes toTypeKind(moduleClassSymbol.info)
-
-        /* AnnotatedType should (probably) be eliminated by erasure. However we know it happens for
-         * meta-annotated annotations (@(ann @getter) val x = 0), so we don't emit a warning.
-         * The type in the AnnotationInfo is an AnnotatedTpe. Tested in jvm/annotations.scala.
-         */
-        case a @ AnnotatedType(_, t) =>
-          debuglog(s"typeKind of annotated type $a")
-          toTypeKind(t)
-
-        /* ExistentialType should (probably) be eliminated by erasure. We know they get here for
-         * classOf constants:
-         *   class C[T]
-         *   class T { final val k = classOf[C[_]] }
-         */
-        case e @ ExistentialType(_, t) =>
-          debuglog(s"typeKind of existential type $e")
-          toTypeKind(t)
-
-        /* The cases below should probably never occur. They are kept for now to avoid introducing
-         * new compiler crashes, but we added a warning. The compiler / library bootstrap and the
-         * test suite don't produce any warning.
-         */
-
-        case tp =>
-          currentUnit.warning(tp.typeSymbol.pos,
-            s"an unexpected type representation reached the compiler backend while compiling $currentUnit: $tp. " +
-            "If possible, please file a bug on issues.scala-lang.org.")
-
-          tp match {
-            case ThisType(ArrayClass)               => ObjectReference // was introduced in 9b17332f11 to fix SI-999, but this code is not reached in its test, or any other test
-            case ThisType(sym)                      => getClassBTypeAndRegisterInnerClass(sym)
-            case SingleType(_, sym)                 => primitiveOrClassToBType(sym)
-            case ConstantType(_)                    => toTypeKind(t.underlying)
-            case RefinedType(parents, _)            => parents.map(toTypeKind(_).asClassBType).reduceLeft((a, b) => a.jvmWiseLUB(b))
-          }
-      }
+    final def toTypeKind(t: Type): BType = typeToBType(t) match {
+      case c: ClassBType if c.isNestedClass.get =>
+        innerClassBufferASM += c
+        c
+      case r => r
     }
 
-    /*
-     * must-single-thread
+    /**
+     * Class components that are nested classes are added to the innerClassBufferASM.
+     * TODO: clean up the way we track referenced inner classes.
      */
     final def asmMethodType(msym: Symbol): MethodBType = {
-      assert(msym.isMethod, s"not a method-symbol: $msym")
-      val resT: BType =
-        if (msym.isClassConstructor || msym.isConstructor) UNIT
-        else toTypeKind(msym.tpe.resultType)
-      MethodBType(msym.tpe.paramTypes map toTypeKind, resT)
+      val r = methodBTypeFromSymbol(msym)
+      (r.returnType :: r.argumentTypes) foreach {
+        case c: ClassBType if c.isNestedClass.get => innerClassBufferASM += c
+        case _ =>
+      }
+      r
     }
 
     /**
@@ -796,7 +715,7 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
       val mirrorClass = new asm.tree.ClassNode
       mirrorClass.visit(
         classfileVersion,
-        bType.info.flags,
+        bType.info.get.flags,
         bType.internalName,
         null /* no java-generic-signature */,
         ObjectReference.internalName,
@@ -812,7 +731,7 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
 
       addForwarders(isRemote(moduleClass), mirrorClass, bType.internalName, moduleClass)
 
-      innerClassBufferASM ++= bType.info.nestedClasses
+      innerClassBufferASM ++= bType.info.get.nestedClasses
       addInnerClassesASM(mirrorClass, innerClassBufferASM.toList)
 
       mirrorClass.visitEnd()
@@ -928,7 +847,7 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
       constructor.visitMaxs(0, 0) // just to follow protocol, dummy arguments
       constructor.visitEnd()
 
-      innerClassBufferASM ++= classBTypeFromSymbol(cls).info.nestedClasses
+      innerClassBufferASM ++= classBTypeFromSymbol(cls).info.get.nestedClasses
       addInnerClassesASM(beanInfoClass, innerClassBufferASM.toList)
 
       beanInfoClass.visitEnd()
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeIdiomatic.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeIdiomatic.scala
index c3db28151b..9993357eee 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeIdiomatic.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeIdiomatic.scala
@@ -10,6 +10,8 @@ package backend.jvm
 import scala.tools.asm
 import scala.annotation.switch
 import scala.collection.mutable
+import GenBCode._
+import scala.tools.asm.tree.MethodInsnNode
 
 /*
  *  A high-level facade to the ASM API for bytecode generation.
@@ -42,9 +44,6 @@ abstract class BCodeIdiomatic extends SubComponent {
 
   val StringBuilderClassName = "scala/collection/mutable/StringBuilder"
 
-  val CLASS_CONSTRUCTOR_NAME    = "<clinit>"
-  val INSTANCE_CONSTRUCTOR_NAME = "<init>"
-
   val EMPTY_STRING_ARRAY   = Array.empty[String]
   val EMPTY_INT_ARRAY      = Array.empty[Int]
   val EMPTY_LABEL_ARRAY    = Array.empty[asm.Label]
@@ -107,7 +106,7 @@ abstract class BCodeIdiomatic extends SubComponent {
    */
   abstract class JCodeMethodN {
 
-    def jmethod: asm.MethodVisitor
+    def jmethod: asm.tree.MethodNode
 
     import asm.Opcodes;
     import icodes.opcodes.{ Static, Dynamic,  SuperCall }
@@ -207,20 +206,21 @@ abstract class BCodeIdiomatic extends SubComponent {
     /*
      * can-multi-thread
      */
-    final def genStartConcat {
+    final def genStartConcat(pos: Position): Unit = {
       jmethod.visitTypeInsn(Opcodes.NEW, StringBuilderClassName)
       jmethod.visitInsn(Opcodes.DUP)
       invokespecial(
         StringBuilderClassName,
         INSTANCE_CONSTRUCTOR_NAME,
-        "()V"
+        "()V",
+        pos
       )
     }
 
     /*
      * can-multi-thread
      */
-    final def genStringConcat(el: BType) {
+    final def genStringConcat(el: BType, pos: Position): Unit = {
 
       val jtype =
         if (el.isArray || el.isClass) ObjectReference
@@ -228,14 +228,14 @@ abstract class BCodeIdiomatic extends SubComponent {
 
       val bt = MethodBType(List(jtype), StringBuilderReference)
 
-      invokevirtual(StringBuilderClassName, "append", bt.descriptor)
+      invokevirtual(StringBuilderClassName, "append", bt.descriptor, pos)
     }
 
     /*
      * can-multi-thread
      */
-    final def genEndConcat {
-      invokevirtual(StringBuilderClassName, "toString", "()Ljava/lang/String;")
+    final def genEndConcat(pos: Position): Unit = {
+      invokevirtual(StringBuilderClassName, "toString", "()Ljava/lang/String;", pos)
     }
 
     /*
@@ -391,20 +391,26 @@ abstract class BCodeIdiomatic extends SubComponent {
     final def rem(tk: BType) { emitPrimitive(JCodeMethodN.remOpcodes, tk) } // can-multi-thread
 
     // can-multi-thread
-    final def invokespecial(owner: String, name: String, desc: String) {
-      jmethod.visitMethodInsn(Opcodes.INVOKESPECIAL, owner, name, desc, false)
+    final def invokespecial(owner: String, name: String, desc: String, pos: Position) {
+      addInvoke(Opcodes.INVOKESPECIAL, owner, name, desc, false, pos)
     }
     // can-multi-thread
-    final def invokestatic(owner: String, name: String, desc: String) {
-      jmethod.visitMethodInsn(Opcodes.INVOKESTATIC, owner, name, desc, false)
+    final def invokestatic(owner: String, name: String, desc: String, pos: Position) {
+      addInvoke(Opcodes.INVOKESTATIC, owner, name, desc, false, pos)
     }
     // can-multi-thread
-    final def invokeinterface(owner: String, name: String, desc: String) {
-      jmethod.visitMethodInsn(Opcodes.INVOKEINTERFACE, owner, name, desc, true)
+    final def invokeinterface(owner: String, name: String, desc: String, pos: Position) {
+      addInvoke(Opcodes.INVOKEINTERFACE, owner, name, desc, true, pos)
     }
     // can-multi-thread
-    final def invokevirtual(owner: String, name: String, desc: String) {
-      jmethod.visitMethodInsn(Opcodes.INVOKEVIRTUAL, owner, name, desc, false)
+    final def invokevirtual(owner: String, name: String, desc: String, pos: Position) {
+      addInvoke(Opcodes.INVOKEVIRTUAL, owner, name, desc, false, pos)
+    }
+
+    private def addInvoke(opcode: Int, owner: String, name: String, desc: String, itf: Boolean, pos: Position) = {
+      val node = new MethodInsnNode(opcode, owner, name, desc, itf)
+      jmethod.instructions.add(node)
+      if (settings.YoptInlinerEnabled) callsitePositions(node) = pos
     }
 
     // can-multi-thread
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala
index 142c901c21..2a06c62e37 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BCodeSkelBuilder.scala
@@ -4,18 +4,17 @@
  */
 
 
-package scala
-package tools.nsc
+package scala.tools.nsc
 package backend
 package jvm
 
 import scala.collection.{ mutable, immutable }
+import scala.tools.nsc.backend.jvm.opt.ByteCodeRepository
 import scala.tools.nsc.symtab._
-import scala.annotation.switch
 
 import scala.tools.asm
-import scala.tools.asm.util.{TraceMethodVisitor, ASMifier}
-import java.io.PrintWriter
+import GenBCode._
+import BackendReporting._
 
 /*
  *
@@ -101,6 +100,8 @@ abstract class BCodeSkelBuilder extends BCodeHelpers {
       isCZRemote        = isRemote(claszSymbol)
       thisName          = internalName(claszSymbol)
 
+      val classBType = classBTypeFromSymbol(claszSymbol)
+
       cnode = new asm.tree.ClassNode()
 
       initJClass(cnode)
@@ -118,16 +119,21 @@ abstract class BCodeSkelBuilder extends BCodeHelpers {
 
       addClassFields()
 
-      innerClassBufferASM ++= classBTypeFromSymbol(claszSymbol).info.nestedClasses
+      innerClassBufferASM ++= classBType.info.get.nestedClasses
       gen(cd.impl)
       addInnerClassesASM(cnode, innerClassBufferASM.toList)
 
+      cnode.visitAttribute(classBType.inlineInfoAttribute.get)
+
       if (AsmUtils.traceClassEnabled && cnode.name.contains(AsmUtils.traceClassPattern))
         AsmUtils.traceClass(cnode)
 
-      cnode.innerClasses
-      assert(cd.symbol == claszSymbol, "Someone messed up BCodePhase.claszSymbol during genPlainClass().")
+      if (settings.YoptInlinerEnabled) {
+        // The inliner needs to find all classes in the code repo, also those being compiled
+        byteCodeRepository.add(cnode, ByteCodeRepository.CompilationUnit)
+      }
 
+      assert(cd.symbol == claszSymbol, "Someone messed up BCodePhase.claszSymbol during genPlainClass().")
     } // end of method genPlainClass()
 
     /*
@@ -137,9 +143,9 @@ abstract class BCodeSkelBuilder extends BCodeHelpers {
 
       val ps = claszSymbol.info.parents
       val superClass: String = if (ps.isEmpty) ObjectReference.internalName else internalName(ps.head.typeSymbol)
-      val interfaceNames = classBTypeFromSymbol(claszSymbol).info.interfaces map {
+      val interfaceNames = classBTypeFromSymbol(claszSymbol).info.get.interfaces map {
         case classBType =>
-          if (classBType.isNestedClass) { innerClassBufferASM += classBType }
+          if (classBType.isNestedClass.get) { innerClassBufferASM += classBType }
           classBType.internalName
       }
 
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala b/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala
index ec26ef9b48..d8a17e975e 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala
@@ -6,18 +6,23 @@
 package scala.tools.nsc
 package backend.jvm
 
+import scala.annotation.switch
+import scala.collection.concurrent.TrieMap
+import scala.reflect.internal.util.Position
 import scala.tools.asm
 import asm.Opcodes
-import scala.tools.asm.tree.{InnerClassNode, ClassNode}
-import opt.ByteCodeRepository
+import scala.tools.asm.tree.{MethodInsnNode, InnerClassNode, ClassNode}
+import scala.tools.nsc.backend.jvm.BTypes.{InlineInfo, MethodInlineInfo}
+import scala.tools.nsc.backend.jvm.BackendReporting._
+import scala.tools.nsc.backend.jvm.opt._
 import scala.collection.convert.decorateAsScala._
 
 /**
- * The BTypes component defines The BType class hierarchy. BTypes encapsulate all type information
+ * The BTypes component defines The BType class hierarchy. A BType stores all type information
  * that is required after building the ASM nodes. This includes optimizations, generation of
  * InnerClass attributes and generation of stack map frames.
  *
- * This representation is immutable and independent of the compiler data structures, hence it can
+ * The representation is immutable and independent of the compiler data structures, hence it can
  * be queried by concurrent threads.
  */
 abstract class BTypes {
@@ -34,9 +39,24 @@ abstract class BTypes {
    */
   val byteCodeRepository: ByteCodeRepository
 
+  val inliner: Inliner[this.type]
+
+  val callGraph: CallGraph[this.type]
+
+  val backendReporting: BackendReporting
+
   // Allows to define per-run caches here and in the CallGraph component, which don't have a global
   def recordPerRunCache[T <: collection.generic.Clearable](cache: T): T
 
+  // When building the call graph, we need to know if global inlining is allowed (the component doesn't have a global)
+  def inlineGlobalEnabled: Boolean
+
+  // When the inliner is not enabled, there's no point in adding InlineInfos to all ClassBTypes
+  def inlinerEnabled: Boolean
+
+  // Settings that define what kind of optimizer warnings are emitted.
+  def warnSettings: WarnSettings
+
   /**
    * A map from internal names to ClassBTypes. Every ClassBType is added to this map on its
    * construction.
@@ -48,13 +68,57 @@ abstract class BTypes {
    * Concurrent because stack map frames are computed when in the class writer, which might run
    * on multiple classes concurrently.
    */
-  val classBTypeFromInternalName: collection.concurrent.Map[InternalName, ClassBType] = recordPerRunCache(collection.concurrent.TrieMap.empty[InternalName, ClassBType])
+  val classBTypeFromInternalName: collection.concurrent.Map[InternalName, ClassBType] = recordPerRunCache(TrieMap.empty)
+
+  /**
+   * Store the position of every MethodInsnNode during code generation. This allows each callsite
+   * in the call graph to remember its source position, which is required for inliner warnings.
+   */
+  val callsitePositions: collection.concurrent.Map[MethodInsnNode, Position] = recordPerRunCache(TrieMap.empty)
+
+  /**
+   * Contains the internal names of all classes that are defined in Java source files of the current
+   * compilation run (mixed compilation). Used for more detailed error reporting.
+   */
+  val javaDefinedClasses: collection.mutable.Set[InternalName] = recordPerRunCache(collection.mutable.Set.empty)
+
+  /**
+   * Obtain the BType for a type descriptor or internal name. For class descriptors, the ClassBType
+   * is constructed by parsing the corresponding classfile.
+   * 
+   * Some JVM operations use either a full descriptor or only an internal name. Example:
+   *   ANEWARRAY java/lang/String    // a new array of strings (internal name for the String class)
+   *   ANEWARRAY [Ljava/lang/String; // a new array of array of string (full descriptor for the String class)
+   *
+   * This method supports both descriptors and internal names.
+   */
+  def bTypeForDescriptorOrInternalNameFromClassfile(desc: String): BType = (desc(0): @switch) match {
+    case 'V'                     => UNIT
+    case 'Z'                     => BOOL
+    case 'C'                     => CHAR
+    case 'B'                     => BYTE
+    case 'S'                     => SHORT
+    case 'I'                     => INT
+    case 'F'                     => FLOAT
+    case 'J'                     => LONG
+    case 'D'                     => DOUBLE
+    case '['                     => ArrayBType(bTypeForDescriptorOrInternalNameFromClassfile(desc.substring(1)))
+    case 'L' if desc.last == ';' => classBTypeFromParsedClassfile(desc.substring(1, desc.length - 1))
+    case _                       => classBTypeFromParsedClassfile(desc)
+  }
 
   /**
-   * Parse the classfile for `internalName` and construct the [[ClassBType]].
+   * Parse the classfile for `internalName` and construct the [[ClassBType]]. If the classfile cannot
+   * be found in the `byteCodeRepository`, the `info` of the resulting ClassBType is undefined.
    */
   def classBTypeFromParsedClassfile(internalName: InternalName): ClassBType = {
-    classBTypeFromClassNode(byteCodeRepository.classNode(internalName))
+    classBTypeFromInternalName.getOrElse(internalName, {
+      val res = ClassBType(internalName)
+      byteCodeRepository.classNode(internalName) match {
+        case Left(msg) => res.info = Left(NoClassBTypeInfoMissingBytecode(msg)); res
+        case Right(c)  => setClassInfoFromParsedClassfile(c, res)
+      }
+    })
   }
 
   /**
@@ -62,11 +126,11 @@ abstract class BTypes {
    */
   def classBTypeFromClassNode(classNode: ClassNode): ClassBType = {
     classBTypeFromInternalName.getOrElse(classNode.name, {
-      setClassInfo(classNode, ClassBType(classNode.name))
+      setClassInfoFromParsedClassfile(classNode, ClassBType(classNode.name))
     })
   }
 
-  private def setClassInfo(classNode: ClassNode, classBType: ClassBType): ClassBType = {
+  private def setClassInfoFromParsedClassfile(classNode: ClassNode, classBType: ClassBType): ClassBType = {
     val superClass = classNode.superName match {
       case null =>
         assert(classNode.name == ObjectReference.internalName, s"class with missing super type: ${classNode.name}")
@@ -89,11 +153,13 @@ abstract class BTypes {
      * For local and anonymous classes, innerClassNode.outerName is null. Such classes are required
      * to have an EnclosingMethod attribute declaring the outer class. So we keep those local and
      * anonymous classes whose outerClass is classNode.name.
-     *
      */
     def nestedInCurrentClass(innerClassNode: InnerClassNode): Boolean = {
       (innerClassNode.outerName != null && innerClassNode.outerName == classNode.name) ||
-      (innerClassNode.outerName == null && byteCodeRepository.classNode(innerClassNode.name).outerClass == classNode.name)
+      (innerClassNode.outerName == null && {
+        val classNodeForInnerClass = byteCodeRepository.classNode(innerClassNode.name).get // TODO: don't get here, but set the info to Left at the end
+        classNodeForInnerClass.outerClass == classNode.name
+      })
     }
 
     val nestedClasses: List[ClassBType] = classNode.innerClasses.asScala.collect({
@@ -116,11 +182,58 @@ abstract class BTypes {
         val staticFlag = (innerEntry.access & Opcodes.ACC_STATIC) != 0
         NestedInfo(enclosingClass, Option(innerEntry.outerName), Option(innerEntry.innerName), staticFlag)
     }
-    classBType.info = ClassInfo(superClass, interfaces, flags, nestedClasses, nestedInfo)
+
+    val inlineInfo = inlineInfoFromClassfile(classNode)
+
+    classBType.info = Right(ClassInfo(superClass, interfaces, flags, nestedClasses, nestedInfo, inlineInfo))
     classBType
   }
 
   /**
+   * Build the InlineInfo for a class. For Scala classes, the information is stored in the
+   * ScalaInlineInfo attribute. If the attribute is missing, the InlineInfo is built using the
+   * metadata available in the classfile (ACC_FINAL flags, etc).
+   */
+  def inlineInfoFromClassfile(classNode: ClassNode): InlineInfo = {
+    def fromClassfileAttribute: Option[InlineInfo] = {
+      if (classNode.attrs == null) None
+      else classNode.attrs.asScala.collect({ case a: InlineInfoAttribute => a}).headOption.map(_.inlineInfo)
+    }
+
+    def fromClassfileWithoutAttribute = {
+      val warning = {
+        val isScala = classNode.attrs != null && classNode.attrs.asScala.exists(a => a.`type` == BTypes.ScalaAttributeName || a.`type` == BTypes.ScalaSigAttributeName)
+        if (isScala) Some(NoInlineInfoAttribute(classNode.name))
+        else None
+      }
+      // when building MethodInlineInfos for the members of a ClassSymbol, we exclude those methods
+      // in scalaPrimitives. This is necessary because some of them have non-erased types, which would
+      // require special handling. Excluding is OK because they are never inlined.
+      // Here we are parsing from a classfile and we don't need to do anything special. Many of these
+      // primitives don't even exist, for example Any.isInstanceOf.
+      val methodInfos = classNode.methods.asScala.map(methodNode => {
+        val info = MethodInlineInfo(
+          effectivelyFinal                    = BytecodeUtils.isFinalMethod(methodNode),
+          traitMethodWithStaticImplementation = false,
+          annotatedInline                     = false,
+          annotatedNoInline                   = false)
+        (methodNode.name + methodNode.desc, info)
+      }).toMap
+      InlineInfo(
+        traitImplClassSelfType = None,
+        isEffectivelyFinal = BytecodeUtils.isFinalClass(classNode),
+        methodInfos = methodInfos,
+        warning)
+    }
+
+    // The InlineInfo is built from the classfile (not from the symbol) for all classes that are NOT
+    // being compiled. For those classes, the info is only needed if the inliner is enabled, othewise
+    // we can save the memory.
+    if (!inlinerEnabled) BTypes.EmptyInlineInfo
+    else fromClassfileAttribute getOrElse fromClassfileWithoutAttribute
+  }
+
+  /**
    * A BType is either a primitive type, a ClassBType, an ArrayBType of one of these, or a MethodType
    * referring to BTypes.
    */
@@ -184,7 +297,7 @@ abstract class BTypes {
      * promotions (e.g. BYTE to INT). Its operation can be visualized more easily in terms of the
      * Java bytecode type hierarchy.
      */
-    final def conformsTo(other: BType): Boolean = {
+    final def conformsTo(other: BType): Either[NoClassBTypeInfo, Boolean] = tryEither(Right({
       assert(isRef || isPrimitive, s"conformsTo cannot handle $this")
       assert(other.isRef || other.isPrimitive, s"conformsTo cannot handle $other")
 
@@ -192,7 +305,7 @@ abstract class BTypes {
         case ArrayBType(component) =>
           if (other == ObjectReference || other == jlCloneableReference || other == jioSerializableReference) true
           else other match {
-            case ArrayBType(otherComponoent) => component.conformsTo(otherComponoent)
+            case ArrayBType(otherComponoent) => component.conformsTo(otherComponoent).orThrow
             case _ => false
           }
 
@@ -201,7 +314,7 @@ abstract class BTypes {
             if (other.isBoxed) this == other
             else if (other == ObjectReference) true
             else other match {
-              case otherClassType: ClassBType => classType.isSubtypeOf(otherClassType) // e.g., java/lang/Double conforms to java/lang/Number
+              case otherClassType: ClassBType => classType.isSubtypeOf(otherClassType).orThrow // e.g., java/lang/Double conforms to java/lang/Number
               case _ => false
             }
           } else if (isNullType) {
@@ -211,7 +324,7 @@ abstract class BTypes {
           } else if (isNothingType) {
             true
           } else other match {
-            case otherClassType: ClassBType => classType.isSubtypeOf(otherClassType)
+            case otherClassType: ClassBType => classType.isSubtypeOf(otherClassType).orThrow
             // case ArrayBType(_) => this.isNullType   // documentation only, because `if (isNullType)` above covers this case
             case _ =>
               // isNothingType ||                      // documentation only, because `if (isNothingType)` above covers this case
@@ -226,7 +339,7 @@ abstract class BTypes {
           assert(isPrimitive && other.isPrimitive, s"Expected primitive types $this - $other")
           this == other
       }
-    }
+    }))
 
     /**
      * Compute the upper bound of two types.
@@ -245,7 +358,7 @@ abstract class BTypes {
         ObjectReference
 
       case _: MethodBType =>
-        throw new AssertionError(s"unexpected method type when computing maxType: $this")
+        assertionError(s"unexpected method type when computing maxType: $this")
     }
 
     /**
@@ -336,7 +449,7 @@ abstract class BTypes {
      */
     final def maxValueType(other: BType): BType = {
 
-      def uncomparable: Nothing = throw new AssertionError(s"Cannot compute maxValueType: $this, $other")
+      def uncomparable: Nothing = assertionError(s"Cannot compute maxValueType: $this, $other")
 
       if (!other.isPrimitive && !other.isNothingType) uncomparable
 
@@ -665,6 +778,21 @@ abstract class BTypes {
   /**
    * A ClassBType represents a class or interface type. The necessary information to build a
    * ClassBType is extracted from compiler symbols and types, see BTypesFromSymbols.
+   *
+   * The `info` field contains either the class information on an error message why the info could
+   * not be computed. There are two reasons for an erroneous info:
+   *   1. The ClassBType was built from a class symbol that stems from a java source file, and the
+   *      symbol's type could not be completed successfully (SI-9111)
+   *   2. The ClassBType should be built from a classfile, but the class could not be found on the
+   *      compilation classpath.
+   *
+   * Note that all ClassBTypes required in a non-optimzied run are built during code generation from
+   * the class symbols referenced by the ASTs, so they have a valid info. Therefore the backend
+   * often invokes `info.get` (which asserts the info to exist) when reading data from the ClassBType.
+   *
+   * The inliner on the other hand uses ClassBTypes that are built from classfiles, which may have
+   * a missing info. In order not to crash the compiler unnecessarily, the inliner does not force
+   * infos using `get`, but it reports inliner warnings for missing infos that prevent inlining.
    */
   final case class ClassBType(internalName: InternalName) extends RefBType {
     /**
@@ -674,14 +802,14 @@ abstract class BTypes {
      *   B.info.nestedInfo.outerClass == A
      *   A.info.nestedClasses contains B
      */
-    private var _info: ClassInfo = null
+    private var _info: Either[NoClassBTypeInfo, ClassInfo] = null
 
-    def info: ClassInfo = {
+    def info: Either[NoClassBTypeInfo, ClassInfo] = {
       assert(_info != null, s"ClassBType.info not yet assigned: $this")
       _info
     }
 
-    def info_=(i: ClassInfo): Unit = {
+    def info_=(i: Either[NoClassBTypeInfo, ClassInfo]): Unit = {
       assert(_info == null, s"Cannot set ClassBType.info multiple times: $this")
       _info = i
       checkInfoConsistency()
@@ -690,27 +818,29 @@ abstract class BTypes {
     classBTypeFromInternalName(internalName) = this
 
     private def checkInfoConsistency(): Unit = {
+      if (info.isLeft) return
+
       // we assert some properties. however, some of the linked ClassBType (members, superClass,
       // interfaces) may not yet have an `_info` (initialization of cyclic structures). so we do a
-      // best-effort verification.
-      def ifInit(c: ClassBType)(p: ClassBType => Boolean): Boolean = c._info == null || p(c)
+      // best-effort verification. also we don't report an error if the info is a Left.
+      def ifInit(c: ClassBType)(p: ClassBType => Boolean): Boolean = c._info == null || c.info.isLeft || p(c)
 
       def isJLO(t: ClassBType) = t.internalName == ObjectReference.internalName
 
       assert(!ClassBType.isInternalPhantomType(internalName), s"Cannot create ClassBType for phantom type $this")
 
       assert(
-        if (info.superClass.isEmpty) { isJLO(this) || (isCompilingPrimitive && ClassBType.hasNoSuper(internalName)) }
-        else if (isInterface) isJLO(info.superClass.get)
-        else !isJLO(this) && ifInit(info.superClass.get)(!_.isInterface),
-        s"Invalid superClass in $this: ${info.superClass}"
+        if (info.get.superClass.isEmpty) { isJLO(this) || (isCompilingPrimitive && ClassBType.hasNoSuper(internalName)) }
+        else if (isInterface.get) isJLO(info.get.superClass.get)
+        else !isJLO(this) && ifInit(info.get.superClass.get)(!_.isInterface.get),
+        s"Invalid superClass in $this: ${info.get.superClass}"
       )
       assert(
-        info.interfaces.forall(c => ifInit(c)(_.isInterface)),
-        s"Invalid interfaces in $this: ${info.interfaces}"
+        info.get.interfaces.forall(c => ifInit(c)(_.isInterface.get)),
+        s"Invalid interfaces in $this: ${info.get.interfaces}"
       )
 
-      assert(info.nestedClasses.forall(c => ifInit(c)(_.isNestedClass)), info.nestedClasses)
+      assert(info.get.nestedClasses.forall(c => ifInit(c)(_.isNestedClass.get)), info.get.nestedClasses)
     }
 
     /**
@@ -718,20 +848,37 @@ abstract class BTypes {
      */
     def simpleName: String = internalName.split("/").last
 
-    def isInterface = (info.flags & asm.Opcodes.ACC_INTERFACE) != 0
+    def isInterface: Either[NoClassBTypeInfo, Boolean] = info.map(i => (i.flags & asm.Opcodes.ACC_INTERFACE) != 0)
+
+    def superClassesTransitive: Either[NoClassBTypeInfo, List[ClassBType]] = info.flatMap(i => i.superClass match {
+      case None => Right(Nil)
+      case Some(sc) =>  sc.superClassesTransitive.map(sc :: _)
+    })
 
-    def superClassesTransitive: List[ClassBType] = info.superClass match {
-      case None => Nil
-      case Some(sc) => sc :: sc.superClassesTransitive
+    /**
+     * The prefix of the internal name until the last '/', or the empty string.
+     */
+    def packageInternalName: String = {
+      val name = internalName
+      name.lastIndexOf('/') match {
+        case -1 => ""
+        case i  => name.substring(0, i)
+      }
     }
 
-    def isNestedClass = info.nestedInfo.isDefined
+    def isPublic: Either[NoClassBTypeInfo, Boolean] = info.map(i => (i.flags & asm.Opcodes.ACC_PUBLIC) != 0)
+
+    def isNestedClass: Either[NoClassBTypeInfo, Boolean] = info.map(_.nestedInfo.isDefined)
 
-    def enclosingNestedClassesChain: List[ClassBType] =
-      if (isNestedClass) this :: info.nestedInfo.get.enclosingClass.enclosingNestedClassesChain
-      else Nil
+    def enclosingNestedClassesChain: Either[NoClassBTypeInfo, List[ClassBType]] = {
+      isNestedClass.flatMap(isNested => {
+        // if isNested is true, we know that info.get is defined, and nestedInfo.get is also defined.
+        if (isNested) info.get.nestedInfo.get.enclosingClass.enclosingNestedClassesChain.map(this :: _)
+        else Right(Nil)
+      })
+    }
 
-    def innerClassAttributeEntry: Option[InnerClassEntry] = info.nestedInfo map {
+    def innerClassAttributeEntry: Either[NoClassBTypeInfo, Option[InnerClassEntry]] = info.map(i => i.nestedInfo map {
       case NestedInfo(_, outerName, innerName, isStaticNestedClass) =>
         InnerClassEntry(
           internalName,
@@ -739,28 +886,39 @@ abstract class BTypes {
           innerName.orNull,
           GenBCode.mkFlags(
             // the static flag in the InnerClass table has a special meaning, see InnerClass comment
-            info.flags & ~Opcodes.ACC_STATIC,
+            i.flags & ~Opcodes.ACC_STATIC,
             if (isStaticNestedClass) Opcodes.ACC_STATIC else 0
           ) & ClassBType.INNER_CLASSES_FLAGS
         )
-    }
+    })
 
-    def isSubtypeOf(other: ClassBType): Boolean = {
-      if (this == other) return true
+    def inlineInfoAttribute: Either[NoClassBTypeInfo, InlineInfoAttribute] = info.map(i => {
+      // InlineInfos are serialized for classes being compiled. For those the info was built by
+      // buildInlineInfoFromClassSymbol, which only adds a warning under SI-9111, which in turn
+      // only happens for class symbols of java source files.
+      // we could put this assertion into InlineInfoAttribute, but it is more safe to put it here
+      // where it affect only GenBCode, and not add any assertion to GenASM in 2.11.6.
+      assert(i.inlineInfo.warning.isEmpty, i.inlineInfo.warning)
+      InlineInfoAttribute(i.inlineInfo)
+    })
 
-      if (isInterface) {
-        if (other == ObjectReference) return true // interfaces conform to Object
-        if (!other.isInterface) return false // this is an interface, the other is some class other than object. interfaces cannot extend classes, so the result is false.
+    def isSubtypeOf(other: ClassBType): Either[NoClassBTypeInfo, Boolean] = try {
+      if (this == other) return Right(true)
+      if (isInterface.orThrow) {
+        if (other == ObjectReference) return Right(true) // interfaces conform to Object
+        if (!other.isInterface.orThrow) return Right(false)   // this is an interface, the other is some class other than object. interfaces cannot extend classes, so the result is false.
         // else: this and other are both interfaces. continue to (*)
       } else {
-        val sc = info.superClass
-        if (sc.isDefined && sc.get.isSubtypeOf(other)) return true // the superclass of this class conforms to other
-        if (!other.isInterface) return false // this and other are both classes, and the superclass of this does not conform
+        val sc = info.orThrow.superClass
+        if (sc.isDefined && sc.get.isSubtypeOf(other).orThrow) return Right(true) // the superclass of this class conforms to other
+        if (!other.isInterface.orThrow) return Right(false) // this and other are both classes, and the superclass of this does not conform
         // else: this is a class, the other is an interface. continue to (*)
       }
 
       // (*) check if some interface of this class conforms to other.
-      info.interfaces.exists(_.isSubtypeOf(other))
+      Right(info.orThrow.interfaces.exists(_.isSubtypeOf(other).orThrow))
+    } catch {
+      case Invalid(noInfo: NoClassBTypeInfo) => Left(noInfo)
     }
 
     /**
@@ -770,34 +928,36 @@ abstract class BTypes {
      *   http://comments.gmane.org/gmane.comp.java.vm.languages/2293
      *   https://issues.scala-lang.org/browse/SI-3872
      */
-    def jvmWiseLUB(other: ClassBType): ClassBType = {
+    def jvmWiseLUB(other: ClassBType): Either[NoClassBTypeInfo, ClassBType] = {
       def isNotNullOrNothing(c: ClassBType) = !c.isNullType && !c.isNothingType
       assert(isNotNullOrNothing(this) && isNotNullOrNothing(other), s"jvmWiseLub for null or nothing: $this - $other")
 
-      val res: ClassBType = (this.isInterface, other.isInterface) match {
-        case (true, true) =>
-          // exercised by test/files/run/t4761.scala
-          if      (other.isSubtypeOf(this)) this
-          else if (this.isSubtypeOf(other)) other
-          else ObjectReference
-
-        case (true, false) =>
-          if (other.isSubtypeOf(this)) this else ObjectReference
-
-        case (false, true) =>
-          if (this.isSubtypeOf(other)) other else ObjectReference
+      tryEither {
+        val res: ClassBType = (this.isInterface.orThrow, other.isInterface.orThrow) match {
+          case (true, true) =>
+            // exercised by test/files/run/t4761.scala
+            if (other.isSubtypeOf(this).orThrow) this
+            else if (this.isSubtypeOf(other).orThrow) other
+            else ObjectReference
+
+          case (true, false) =>
+            if (other.isSubtypeOf(this).orThrow) this else ObjectReference
+
+          case (false, true) =>
+            if (this.isSubtypeOf(other).orThrow) other else ObjectReference
+
+          case _ =>
+            // TODO @lry I don't really understand the reasoning here.
+            // Both this and other are classes. The code takes (transitively) all superclasses and
+            // finds the first common one.
+            // MOST LIKELY the answer can be found here, see the comments and links by Miguel:
+            //  - https://issues.scala-lang.org/browse/SI-3872
+            firstCommonSuffix(this :: this.superClassesTransitive.orThrow, other :: other.superClassesTransitive.orThrow)
+        }
 
-        case _ =>
-          // TODO @lry I don't really understand the reasoning here.
-          // Both this and other are classes. The code takes (transitively) all superclasses and
-          // finds the first common one.
-          // MOST LIKELY the answer can be found here, see the comments and links by Miguel:
-          //  - https://issues.scala-lang.org/browse/SI-3872
-          firstCommonSuffix(this :: this.superClassesTransitive, other :: other.superClassesTransitive)
+        assert(isNotNullOrNothing(res), s"jvmWiseLub computed: $res")
+        Right(res)
       }
-
-      assert(isNotNullOrNothing(res), s"jvmWiseLub computed: $res")
-      res
     }
 
     private def firstCommonSuffix(as: List[ClassBType], bs: List[ClassBType]): ClassBType = {
@@ -859,9 +1019,11 @@ abstract class BTypes {
    * @param nestedClasses Classes nested in this class. Those need to be added to the
    *                      InnerClass table, see the InnerClass spec summary above.
    * @param nestedInfo    If this describes a nested class, information for the InnerClass table.
+   * @param inlineInfo    Information about this class for the inliner.
    */
   final case class ClassInfo(superClass: Option[ClassBType], interfaces: List[ClassBType], flags: Int,
-                             nestedClasses: List[ClassBType], nestedInfo: Option[NestedInfo])
+                             nestedClasses: List[ClassBType], nestedInfo: Option[NestedInfo],
+                             inlineInfo: InlineInfo)
 
   /**
    * Information required to add a class to an InnerClass table.
@@ -962,11 +1124,15 @@ object BTypes {
    * @param methodInfos            The [[MethodInlineInfo]]s for the methods declared in this class.
    *                               The map is indexed by the string s"$name$descriptor" (to
    *                               disambiguate overloads).
+   *
+   * @param warning                Contains an warning message if an error occured when building this
+   *                               InlineInfo, for example if some classfile could not be found on
+   *                               the classpath. This warning can be reported later by the inliner.
    */
   final case class InlineInfo(traitImplClassSelfType: Option[InternalName],
                               isEffectivelyFinal: Boolean,
                               methodInfos: Map[String, MethodInlineInfo],
-                              warning: Option[String])
+                              warning: Option[ClassInlineInfoWarning])
 
   val EmptyInlineInfo = InlineInfo(None, false, Map.empty, None)
 
@@ -984,4 +1150,8 @@ object BTypes {
                                     traitMethodWithStaticImplementation: Boolean,
                                     annotatedInline: Boolean,
                                     annotatedNoInline: Boolean)
+
+  // no static way (without symbol table instance) to get to nme.ScalaATTR / ScalaSignatureATTR
+  val ScalaAttributeName    = "Scala"
+  val ScalaSigAttributeName = "ScalaSig"
 }
\ No newline at end of file
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala b/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala
index 2af665d31c..eeb6ed24a2 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BTypesFromSymbols.scala
@@ -7,10 +7,9 @@ package scala.tools.nsc
 package backend.jvm
 
 import scala.tools.asm
-import opt.ByteCodeRepository
-import scala.tools.asm.tree.ClassNode
-import scala.tools.nsc.backend.jvm.opt.ByteCodeRepository.Source
-import BTypes.InternalName
+import scala.tools.nsc.backend.jvm.opt.{CallGraph, Inliner, ByteCodeRepository}
+import scala.tools.nsc.backend.jvm.BTypes.{InlineInfo, MethodInlineInfo, InternalName}
+import BackendReporting._
 
 /**
  * This class mainly contains the method classBTypeFromSymbol, which extracts the necessary
@@ -36,7 +35,13 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
   val coreBTypes = new CoreBTypesProxy[this.type](this)
   import coreBTypes._
 
-  val byteCodeRepository = new ByteCodeRepository(global.classPath, recordPerRunCache(collection.concurrent.TrieMap.empty[InternalName, (ClassNode, Source)]))
+  val byteCodeRepository = new ByteCodeRepository(global.classPath, javaDefinedClasses, recordPerRunCache(collection.concurrent.TrieMap.empty))
+
+  val inliner: Inliner[this.type] = new Inliner(this)
+
+  val callGraph: CallGraph[this.type] = new CallGraph(this)
+
+  val backendReporting: BackendReporting = new BackendReportingImpl(global)
 
   final def initializeCoreBTypes(): Unit = {
     coreBTypes.setBTypes(new CoreBTypes[this.type](this))
@@ -44,6 +49,20 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
 
   def recordPerRunCache[T <: collection.generic.Clearable](cache: T): T = perRunCaches.recordCache(cache)
 
+  def inlineGlobalEnabled: Boolean = settings.YoptInlineGlobal
+
+  def inlinerEnabled: Boolean      = settings.YoptInlinerEnabled
+
+  def warnSettings: WarnSettings   = {
+    val c = settings.YoptWarningsChoices
+    // cannot extract settings.YoptWarnings into a local val due to some dependent typing issue.
+    WarnSettings(
+      !settings.YoptWarnings.isSetByUser || settings.YoptWarnings.contains(c.atInlineFailedSummary.name) || settings.YoptWarnings.contains(c.atInlineFailed.name),
+      settings.YoptWarnings.contains(c.noInlineMixed.name),
+      settings.YoptWarnings.contains(c.noInlineMissingBytecode.name),
+      settings.YoptWarnings.contains(c.noInlineMissingScalaInlineInfoAttr.name))
+  }
+
   // helpers that need access to global.
   // TODO @lry create a separate component, they don't belong to BTypesFromSymbols
 
@@ -76,22 +95,131 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
   // end helpers
 
   /**
-   * The ClassBType for a class symbol `sym`.
+   * The ClassBType for a class symbol `classSym`.
+   *
+   * The class symbol scala.Nothing is mapped to the class scala.runtime.Nothing$. Similarly,
+   * scala.Null is mapped to scala.runtime.Null$. This is because there exist no class files
+   * for the Nothing / Null. If used for example as a parameter type, we use the runtime classes
+   * in the classfile method signature.
+   *
+   * Note that the referenced class symbol may be an implementation class. For example when
+   * compiling a mixed-in method that forwards to the static method in the implementation class,
+   * the class descriptor of the receiver (the implementation class) is obtained by creating the
+   * ClassBType.
    */
   final def classBTypeFromSymbol(classSym: Symbol): ClassBType = {
     assert(classSym != NoSymbol, "Cannot create ClassBType from NoSymbol")
     assert(classSym.isClass, s"Cannot create ClassBType from non-class symbol $classSym")
-    assert(
-      (!primitiveTypeMap.contains(classSym) || isCompilingPrimitive) &&
-      (classSym != NothingClass && classSym != NullClass),
-      s"Cannot create ClassBType for special class symbol ${classSym.fullName}")
+    assertClassNotArrayNotPrimitive(classSym)
+    assert(!primitiveTypeMap.contains(classSym) || isCompilingPrimitive, s"Cannot create ClassBType for primitive class symbol $classSym")
+    if (classSym == NothingClass) RT_NOTHING
+    else if (classSym == NullClass) RT_NULL
+    else {
+      val internalName = classSym.javaBinaryName.toString
+      classBTypeFromInternalName.getOrElse(internalName, {
+        // The new ClassBType is added to the map in its constructor, before we set its info. This
+        // allows initializing cyclic dependencies, see the comment on variable ClassBType._info.
+        val res = ClassBType(internalName)
+        if (completeSilentlyAndCheckErroneous(classSym)) {
+          res.info = Left(NoClassBTypeInfoClassSymbolInfoFailedSI9111(classSym.fullName))
+          res
+        } else {
+          setClassInfo(classSym, res)
+        }
+      })
+    }
+  }
 
-    val internalName = classSym.javaBinaryName.toString
-    classBTypeFromInternalName.getOrElse(internalName, {
-      // The new ClassBType is added to the map in its constructor, before we set its info. This
-      // allows initializing cyclic dependencies, see the comment on variable ClassBType._info.
-      setClassInfo(classSym, ClassBType(internalName))
-    })
+  /**
+   * Builds a [[MethodBType]] for a method symbol.
+   */
+  final def methodBTypeFromSymbol(methodSymbol: Symbol): MethodBType = {
+    assert(methodSymbol.isMethod, s"not a method-symbol: $methodSymbol")
+    val resultType: BType =
+      if (methodSymbol.isClassConstructor || methodSymbol.isConstructor) UNIT
+      else typeToBType(methodSymbol.tpe.resultType)
+    MethodBType(methodSymbol.tpe.paramTypes map typeToBType, resultType)
+  }
+
+  /**
+   * This method returns the BType for a type reference, for example a parameter type.
+   *
+   * If `t` references a class, typeToBType ensures that the class is not an implementation class.
+   * See also comment on classBTypeFromSymbol, which is invoked for implementation classes.
+   */
+  final def typeToBType(t: Type): BType = {
+    import definitions.ArrayClass
+
+    /**
+     * Primitive types are represented as TypeRefs to the class symbol of, for example, scala.Int.
+     * The `primitiveTypeMap` maps those class symbols to the corresponding PrimitiveBType.
+     */
+    def primitiveOrClassToBType(sym: Symbol): BType = {
+      assertClassNotArray(sym)
+      assert(!sym.isImplClass, sym)
+      primitiveTypeMap.getOrElse(sym, classBTypeFromSymbol(sym))
+    }
+
+    /**
+     * When compiling Array.scala, the type parameter T is not erased and shows up in method
+     * signatures, e.g. `def apply(i: Int): T`. A TyperRef to T is replaced by ObjectReference.
+     */
+    def nonClassTypeRefToBType(sym: Symbol): ClassBType = {
+      assert(sym.isType && isCompilingArray, sym)
+      ObjectReference
+    }
+
+    t.dealiasWiden match {
+      case TypeRef(_, ArrayClass, List(arg))  => ArrayBType(typeToBType(arg)) // Array type such as Array[Int] (kept by erasure)
+      case TypeRef(_, sym, _) if !sym.isClass => nonClassTypeRefToBType(sym)  // See comment on nonClassTypeRefToBType
+      case TypeRef(_, sym, _)                 => primitiveOrClassToBType(sym) // Common reference to a type such as scala.Int or java.lang.String
+      case ClassInfoType(_, _, sym)           => primitiveOrClassToBType(sym) // We get here, for example, for genLoadModule, which invokes typeToBType(moduleClassSymbol.info)
+
+      /* AnnotatedType should (probably) be eliminated by erasure. However we know it happens for
+       * meta-annotated annotations (@(ann @getter) val x = 0), so we don't emit a warning.
+       * The type in the AnnotationInfo is an AnnotatedTpe. Tested in jvm/annotations.scala.
+       */
+      case a @ AnnotatedType(_, t) =>
+        debuglog(s"typeKind of annotated type $a")
+        typeToBType(t)
+
+      /* ExistentialType should (probably) be eliminated by erasure. We know they get here for
+       * classOf constants:
+       *   class C[T]
+       *   class T { final val k = classOf[C[_]] }
+       */
+      case e @ ExistentialType(_, t) =>
+        debuglog(s"typeKind of existential type $e")
+        typeToBType(t)
+
+      /* The cases below should probably never occur. They are kept for now to avoid introducing
+       * new compiler crashes, but we added a warning. The compiler / library bootstrap and the
+       * test suite don't produce any warning.
+       */
+
+      case tp =>
+        currentUnit.warning(tp.typeSymbol.pos,
+          s"an unexpected type representation reached the compiler backend while compiling $currentUnit: $tp. " +
+            "If possible, please file a bug on issues.scala-lang.org.")
+
+        tp match {
+          case ThisType(ArrayClass)               => ObjectReference // was introduced in 9b17332f11 to fix SI-999, but this code is not reached in its test, or any other test
+          case ThisType(sym)                      => classBTypeFromSymbol(sym)
+          case SingleType(_, sym)                 => primitiveOrClassToBType(sym)
+          case ConstantType(_)                    => typeToBType(t.underlying)
+          case RefinedType(parents, _)            => parents.map(typeToBType(_).asClassBType).reduceLeft((a, b) => a.jvmWiseLUB(b).get)
+        }
+    }
+  }
+
+  def assertClassNotArray(sym: Symbol): Unit = {
+    assert(sym.isClass, sym)
+    assert(sym != definitions.ArrayClass || isCompilingArray, sym)
+  }
+
+  def assertClassNotArrayNotPrimitive(sym: Symbol): Unit = {
+    assertClassNotArray(sym)
+    assert(!primitiveTypeMap.contains(sym) || isCompilingPrimitive, sym)
   }
 
   private def setClassInfo(classSym: Symbol, classBType: ClassBType): ClassBType = {
@@ -215,7 +343,9 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
 
     val nestedInfo = buildNestedInfo(classSym)
 
-    classBType.info = ClassInfo(superClass, interfaces, flags, nestedClasses, nestedInfo)
+    val inlineInfo = buildInlineInfo(classSym, classBType.internalName)
+
+    classBType.info = Right(ClassInfo(superClass, interfaces, flags, nestedClasses, nestedInfo, inlineInfo))
     classBType
   }
 
@@ -271,6 +401,40 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
   }
 
   /**
+   * Build the InlineInfo for a ClassBType from the class symbol.
+   *
+   * Note that the InlineInfo is only built from the symbolic information for classes that are being
+   * compiled. For all other classes we delegate to inlineInfoFromClassfile. The reason is that
+   * mixed-in methods are only added to class symbols being compiled, but not to other classes
+   * extending traits. Creating the InlineInfo from the symbol would prevent these mixins from being
+   * inlined.
+   *
+   * So for classes being compiled, the InlineInfo is created here and stored in the ScalaInlineInfo
+   * classfile attribute.
+   */
+  private def buildInlineInfo(classSym: Symbol, internalName: InternalName): InlineInfo = {
+    def buildFromSymbol = buildInlineInfoFromClassSymbol(classSym, classBTypeFromSymbol(_).internalName, methodBTypeFromSymbol(_).descriptor)
+
+    // phase travel required, see implementation of `compiles`. for nested classes, it checks if the
+    // enclosingTopLevelClass is being compiled. after flatten, all classes are considered top-level,
+    // so `compiles` would return `false`.
+    if (exitingPickler(currentRun.compiles(classSym))) buildFromSymbol // InlineInfo required for classes being compiled, we have to create the classfile attribute
+    else if (!inlinerEnabled) BTypes.EmptyInlineInfo                   // For other classes, we need the InlineInfo only inf the inliner is enabled.
+    else {
+      // For classes not being compiled, the InlineInfo is read from the classfile attribute. This
+      // fixes an issue with mixed-in methods: the mixin phase enters mixin methods only to class
+      // symbols being compiled. For non-compiled classes, we could not build MethodInlineInfos
+      // for those mixin members, which prevents inlining.
+      byteCodeRepository.classNode(internalName) match {
+        case Right(classNode) =>
+          inlineInfoFromClassfile(classNode)
+        case Left(missingClass) =>
+          InlineInfo(None, false, Map.empty, Some(ClassNotFoundWhenBuildingInlineInfoFromSymbol(missingClass)))
+      }
+    }
+  }
+
+  /**
    * For top-level objects without a companion class, the compilere generates a mirror class with
    * static forwarders (Java compat). There's no symbol for the mirror class, but we still need a
    * ClassBType (its info.nestedClasses will hold the InnerClass entries, see comment in BTypes).
@@ -282,13 +446,13 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
       val c = ClassBType(internalName)
       // class info consistent with BCodeHelpers.genMirrorClass
       val nested = exitingPickler(memberClassesForInnerClassTable(moduleClassSym)) map classBTypeFromSymbol
-      c.info = ClassInfo(
+      c.info = Right(ClassInfo(
         superClass = Some(ObjectReference),
         interfaces = Nil,
         flags = asm.Opcodes.ACC_SUPER | asm.Opcodes.ACC_PUBLIC | asm.Opcodes.ACC_FINAL,
         nestedClasses = nested,
-        nestedInfo = None
-      )
+        nestedInfo = None,
+        InlineInfo(None, true, Map.empty, None))) // no InlineInfo needed, scala never invokes methods on the mirror class
       c
     })
   }
@@ -322,8 +486,8 @@ class BTypesFromSymbols[G <: Global](val global: G) extends BTypes {
   }
 
   // legacy, to be removed when the @remote annotation gets removed
-  final def isRemote(s: Symbol) = (s hasAnnotation definitions.RemoteAttr)
-  final def hasPublicBitSet(flags: Int) = ((flags & asm.Opcodes.ACC_PUBLIC) != 0)
+  final def isRemote(s: Symbol) = s hasAnnotation definitions.RemoteAttr
+  final def hasPublicBitSet(flags: Int) = (flags & asm.Opcodes.ACC_PUBLIC) != 0
 
   /**
    * Return the Java modifiers for the given symbol.
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BackendReporting.scala b/src/compiler/scala/tools/nsc/backend/jvm/BackendReporting.scala
new file mode 100644
index 0000000000..a06fb4bab8
--- /dev/null
+++ b/src/compiler/scala/tools/nsc/backend/jvm/BackendReporting.scala
@@ -0,0 +1,265 @@
+package scala.tools.nsc
+package backend.jvm
+
+import scala.tools.asm.tree.{AbstractInsnNode, MethodNode}
+import scala.tools.nsc.backend.jvm.BTypes.InternalName
+import scala.reflect.internal.util.Position
+
+/**
+ * Interface for emitting inline warnings. The interface is required because the implementation
+ * depends on Global, which is not available in BTypes (only in BTypesFromSymbols).
+ */
+sealed abstract class BackendReporting {
+  def inlinerWarning(pos: Position, message: String): Unit
+}
+
+final class BackendReportingImpl(val global: Global) extends BackendReporting {
+  import global._
+
+  def inlinerWarning(pos: Position, message: String): Unit = {
+    currentRun.reporting.inlinerWarning(pos, message)
+  }
+}
+
+/**
+ * Utilities for error reporting.
+ *
+ * Defines some tools to make error reporting with Either easier. Would be subsumed by a right-biased
+ * Either in the standard library (or scalaz \/) (Validation is different, it accumulates multiple
+ * errors).
+ */
+object BackendReporting {
+  def methodSignature(classInternalName: InternalName, name: String, desc: String) = {
+    classInternalName + "::" + name + desc
+  }
+
+  def methodSignature(classInternalName: InternalName, method: MethodNode): String = {
+    methodSignature(classInternalName, method.name, method.desc)
+  }
+
+  def assertionError(message: String): Nothing = throw new AssertionError(message)
+
+  implicit class RightBiasedEither[A, B](val v: Either[A, B]) extends AnyVal {
+    def map[U](f: B => U) = v.right.map(f)
+    def flatMap[BB](f: B => Either[A, BB]) = v.right.flatMap(f)
+    def filter(f: B => Boolean)(implicit empty: A): Either[A, B] = v match {
+      case Left(_)  => v
+      case Right(e) => if (f(e)) v else Left(empty) // scalaz.\/ requires an implicit Monoid m to get m.empty
+    }
+    def foreach[U](f: B => U) = v.right.foreach(f)
+
+    def getOrElse[BB >: B](alt: => BB): BB = v.right.getOrElse(alt)
+
+    /**
+     * Get the value, fail with an assertion if this is an error.
+     */
+    def get: B = {
+      assert(v.isRight, v.left.get)
+      v.right.get
+    }
+
+    /**
+     * Get the right value of an `Either` by throwing a potential error message. Can simplify the
+     * implementation of methods that act on multiple `Either` instances. Instead of flat-mapping,
+     * the first error can be collected as
+     *
+     *     tryEither {
+     *       eitherOne.orThrow .... eitherTwo.orThrow ... eitherThree.orThrow
+     *     }
+     */
+    def orThrow: B = v match {
+      case Left(m)  => throw Invalid(m)
+      case Right(t) => t
+    }
+  }
+
+  case class Invalid[A](e: A) extends Exception
+
+  /**
+   * See documentation of orThrow above.
+   */
+  def tryEither[A, B](op: => Either[A, B]): Either[A, B] = try { op } catch { case Invalid(e) => Left(e.asInstanceOf[A]) }
+
+  final case class WarnSettings(atInlineFailed: Boolean, noInlineMixed: Boolean, noInlineMissingBytecode: Boolean, noInlineMissingScalaInlineInfoAttr: Boolean)
+
+  sealed trait OptimizerWarning {
+    def emitWarning(settings: WarnSettings): Boolean
+  }
+
+  // Method filter in RightBiasedEither requires an implicit empty value. Taking the value here
+  // in scope allows for-comprehensions that desugar into filter calls (for example when using a
+  // tuple de-constructor).
+  implicit object emptyOptimizerWarning extends OptimizerWarning {
+    def emitWarning(settings: WarnSettings): Boolean = false
+  }
+
+  sealed trait MissingBytecodeWarning extends OptimizerWarning {
+    override def toString = this match {
+      case ClassNotFound(internalName, definedInJavaSource) =>
+        s"The classfile for $internalName could not be found on the compilation classpath." + {
+          if (definedInJavaSource) "\nThe class is defined in a Java source file that is being compiled (mixed compilation), therefore no bytecode is available."
+          else ""
+        }
+
+      case MethodNotFound(name, descriptor, ownerInternalName, missingClasses) =>
+        val (javaDef, others) = missingClasses.partition(_.definedInJavaSource)
+        s"The method $name$descriptor could not be found in the class $ownerInternalName or any of its parents." +
+          (if (others.isEmpty) "" else others.map(_.internalName).mkString("\nNote that the following parent classes could not be found on the classpath: ", ", ", "")) +
+          (if (javaDef.isEmpty) "" else javaDef.map(_.internalName).mkString("\nNote that the following parent classes are defined in Java sources (mixed compilation), no bytecode is available: ", ",", ""))
+
+      case FieldNotFound(name, descriptor, ownerInternalName, missingClass) =>
+        s"The field node $name$descriptor could not be found because the classfile $ownerInternalName cannot be found on the classpath." +
+          missingClass.map(c => s" Reason:\n$c").getOrElse("")
+    }
+
+    def emitWarning(settings: WarnSettings): Boolean = this match {
+      case ClassNotFound(_, javaDefined) =>
+        if (javaDefined) settings.noInlineMixed
+        else settings.noInlineMissingBytecode
+
+      case m @ MethodNotFound(_, _, _, missing) =>
+        if (m.isArrayMethod) false
+        else settings.noInlineMissingBytecode || missing.exists(_.emitWarning(settings))
+
+      case FieldNotFound(_, _, _, missing) =>
+        settings.noInlineMissingBytecode || missing.exists(_.emitWarning(settings))
+    }
+  }
+
+  case class ClassNotFound(internalName: InternalName, definedInJavaSource: Boolean) extends MissingBytecodeWarning
+  case class MethodNotFound(name: String, descriptor: String, ownerInternalNameOrArrayDescriptor: InternalName, missingClasses: List[ClassNotFound]) extends MissingBytecodeWarning {
+    def isArrayMethod = ownerInternalNameOrArrayDescriptor.charAt(0) == '['
+  }
+  case class FieldNotFound(name: String, descriptor: String, ownerInternalName: InternalName, missingClass: Option[ClassNotFound]) extends MissingBytecodeWarning
+
+  sealed trait NoClassBTypeInfo extends OptimizerWarning {
+    override def toString = this match {
+      case NoClassBTypeInfoMissingBytecode(cause) =>
+        cause.toString
+
+      case NoClassBTypeInfoClassSymbolInfoFailedSI9111(classFullName) =>
+        s"Failed to get the type of class symbol $classFullName due to SI-9111."
+    }
+
+    def emitWarning(settings: WarnSettings): Boolean = this match {
+      case NoClassBTypeInfoMissingBytecode(cause)         => cause.emitWarning(settings)
+      case NoClassBTypeInfoClassSymbolInfoFailedSI9111(_) => settings.noInlineMissingBytecode
+    }
+  }
+
+  case class NoClassBTypeInfoMissingBytecode(cause: MissingBytecodeWarning) extends NoClassBTypeInfo
+  case class NoClassBTypeInfoClassSymbolInfoFailedSI9111(classFullName: String) extends NoClassBTypeInfo
+
+  /**
+   * Used in the CallGraph for nodes where an issue occurred determining the callee information.
+   */
+  sealed trait CalleeInfoWarning extends OptimizerWarning {
+    def declarationClass: InternalName
+    def name: String
+    def descriptor: String
+
+    def warningMessageSignature = BackendReporting.methodSignature(declarationClass, name, descriptor)
+
+    override def toString = this match {
+      case MethodInlineInfoIncomplete(_, _, _, cause) =>
+        s"The inline information for $warningMessageSignature may be incomplete:\n" + cause
+
+      case MethodInlineInfoMissing(_, _, _, cause) =>
+        s"No inline information for method $warningMessageSignature could be found." +
+          cause.map(" Possible reason:\n" + _).getOrElse("")
+
+      case MethodInlineInfoError(_, _, _, cause) =>
+        s"Error while computing the inline information for method $warningMessageSignature:\n" + cause
+
+      case RewriteTraitCallToStaticImplMethodFailed(_, _, _, cause) =>
+        cause.toString
+    }
+
+    def emitWarning(settings: WarnSettings): Boolean = this match {
+      case MethodInlineInfoIncomplete(_, _, _, cause)               => cause.emitWarning(settings)
+
+      case MethodInlineInfoMissing(_, _, _, Some(cause))            => cause.emitWarning(settings)
+      case MethodInlineInfoMissing(_, _, _, None)                   => settings.noInlineMissingBytecode
+
+      case MethodInlineInfoError(_, _, _, cause)                    => cause.emitWarning(settings)
+
+      case RewriteTraitCallToStaticImplMethodFailed(_, _, _, cause) => cause.emitWarning(settings)
+    }
+  }
+
+  case class MethodInlineInfoIncomplete(declarationClass: InternalName, name: String, descriptor: String, cause: ClassInlineInfoWarning) extends CalleeInfoWarning
+  case class MethodInlineInfoMissing(declarationClass: InternalName, name: String, descriptor: String, cause: Option[ClassInlineInfoWarning]) extends CalleeInfoWarning
+  case class MethodInlineInfoError(declarationClass: InternalName, name: String, descriptor: String, cause: NoClassBTypeInfo) extends CalleeInfoWarning
+  case class RewriteTraitCallToStaticImplMethodFailed(declarationClass: InternalName, name: String, descriptor: String, cause: OptimizerWarning) extends CalleeInfoWarning
+
+  sealed trait CannotInlineWarning extends OptimizerWarning {
+    def calleeDeclarationClass: InternalName
+    def name: String
+    def descriptor: String
+
+    def calleeMethodSig = BackendReporting.methodSignature(calleeDeclarationClass, name, descriptor)
+
+    override def toString = this match {
+      case IllegalAccessInstruction(_, _, _, callsiteClass, instruction) =>
+        s"The callee $calleeMethodSig contains the instruction ${AsmUtils.textify(instruction)}" +
+          s"\nthat would cause an IllegalAccessError when inlined into class $callsiteClass."
+
+      case IllegalAccessCheckFailed(_, _, _, callsiteClass, instruction, cause) =>
+        s"Failed to check if $calleeMethodSig can be safely inlined to $callsiteClass without causing an IllegalAccessError. Checking instruction ${AsmUtils.textify(instruction)} failed:\n" + cause
+
+      case MethodWithHandlerCalledOnNonEmptyStack(_, _, _, callsiteClass, callsiteName, callsiteDesc) =>
+        s"""The operand stack at the callsite in ${BackendReporting.methodSignature(callsiteClass, callsiteName, callsiteDesc)} contains more values than the
+           |arguments expected by the callee $calleeMethodSig. These values would be discarded
+           |when entering an exception handler declared in the inlined method.""".stripMargin
+
+      case SynchronizedMethod(_, _, _) =>
+        s"Method $calleeMethodSig cannot be inlined because it is synchronized."
+    }
+
+    def emitWarning(settings: WarnSettings): Boolean = this match {
+      case _: IllegalAccessInstruction | _: MethodWithHandlerCalledOnNonEmptyStack | _: SynchronizedMethod =>
+        settings.atInlineFailed
+
+      case IllegalAccessCheckFailed(_, _, _, _, _, cause) =>
+        cause.emitWarning(settings)
+    }
+  }
+  case class IllegalAccessInstruction(calleeDeclarationClass: InternalName, name: String, descriptor: String,
+                                      callsiteClass: InternalName, instruction: AbstractInsnNode) extends CannotInlineWarning
+  case class IllegalAccessCheckFailed(calleeDeclarationClass: InternalName, name: String, descriptor: String,
+                                      callsiteClass: InternalName, instruction: AbstractInsnNode, cause: OptimizerWarning) extends CannotInlineWarning
+  case class MethodWithHandlerCalledOnNonEmptyStack(calleeDeclarationClass: InternalName, name: String, descriptor: String,
+                                                    callsiteClass: InternalName, callsiteName: String, callsiteDesc: String) extends CannotInlineWarning
+  case class SynchronizedMethod(calleeDeclarationClass: InternalName, name: String, descriptor: String) extends CannotInlineWarning
+
+  /**
+   * Used in the InlineInfo of a ClassBType, when some issue occurred obtaining the inline information.
+   */
+  sealed trait ClassInlineInfoWarning extends OptimizerWarning {
+    override def toString = this match {
+      case NoInlineInfoAttribute(internalName) =>
+        s"The Scala classfile $internalName does not have a ScalaInlineInfo attribute."
+
+      case ClassSymbolInfoFailureSI9111(classFullName) =>
+        s"Failed to get the type of a method of class symbol $classFullName due to SI-9111."
+
+      case ClassNotFoundWhenBuildingInlineInfoFromSymbol(missingClass) =>
+        s"Failed to build the inline information: $missingClass."
+
+      case UnknownScalaInlineInfoVersion(internalName, version) =>
+        s"Cannot read ScalaInlineInfo version $version in classfile $internalName. Use a more recent compiler."
+    }
+
+    def emitWarning(settings: WarnSettings): Boolean = this match {
+      case NoInlineInfoAttribute(_)                             => settings.noInlineMissingScalaInlineInfoAttr
+      case ClassNotFoundWhenBuildingInlineInfoFromSymbol(cause) => cause.emitWarning(settings)
+      case ClassSymbolInfoFailureSI9111(_)                      => settings.noInlineMissingBytecode
+      case UnknownScalaInlineInfoVersion(_, _)                  => settings.noInlineMissingScalaInlineInfoAttr
+    }
+  }
+
+  case class NoInlineInfoAttribute(internalName: InternalName) extends ClassInlineInfoWarning
+  case class ClassSymbolInfoFailureSI9111(classFullName: String) extends ClassInlineInfoWarning
+  case class ClassNotFoundWhenBuildingInlineInfoFromSymbol(missingClass: ClassNotFound) extends ClassInlineInfoWarning
+  case class UnknownScalaInlineInfoVersion(internalName: InternalName, version: Int) extends ClassInlineInfoWarning
+}
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/CoreBTypes.scala b/src/compiler/scala/tools/nsc/backend/jvm/CoreBTypes.scala
index 246235f395..492fe3ae79 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/CoreBTypes.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/CoreBTypes.scala
@@ -99,10 +99,9 @@ class CoreBTypes[BTFS <: BTypesFromSymbols[_ <: Global]](val bTypes: BTFS) {
    *
    * Therefore, when RT_NOTHING or RT_NULL are to be emitted, a mapping is needed: the internal
    * names of NothingClass and NullClass can't be emitted as-is.
-   * TODO @lry Once there's a 2.11.3 starr, use the commented argument list. The current starr crashes on the type literal `scala.runtime.Nothing$`
    */
-  lazy val RT_NOTHING : ClassBType = classBTypeFromSymbol(rootMirror.getRequiredClass("scala.runtime.Nothing$")) // (requiredClass[scala.runtime.Nothing$])
-  lazy val RT_NULL    : ClassBType = classBTypeFromSymbol(rootMirror.getRequiredClass("scala.runtime.Null$"))    // (requiredClass[scala.runtime.Null$])
+  lazy val RT_NOTHING : ClassBType = classBTypeFromSymbol(requiredClass[scala.runtime.Nothing$])
+  lazy val RT_NULL    : ClassBType = classBTypeFromSymbol(requiredClass[scala.runtime.Null$])
 
   lazy val ObjectReference   : ClassBType = classBTypeFromSymbol(ObjectClass)
   lazy val objArrayReference : ArrayBType = ArrayBType(ObjectReference)
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala
index d5e95c47cf..be1595dc29 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/GenBCode.scala
@@ -217,11 +217,26 @@ abstract class GenBCode extends BCodeSyncAndTry {
     class Worker2 {
       lazy val localOpt = new LocalOpt(settings)
 
+      def runGlobalOptimizations(): Unit = {
+        import scala.collection.convert.decorateAsScala._
+        q2.asScala foreach {
+          case Item2(_, _, plain, _, _) =>
+            // skip mirror / bean: wd don't inline into tem, and they are not used in the plain class
+            if (plain != null) {
+              localOpt.minimalRemoveUnreachableCode(plain)
+              callGraph.addClass(plain)
+            }
+        }
+        bTypes.inliner.runInliner()
+      }
+
       def localOptimizations(classNode: ClassNode): Unit = {
         BackendStats.timed(BackendStats.methodOptTimer)(localOpt.methodOptimizations(classNode))
       }
 
       def run() {
+        if (settings.YoptInlinerEnabled) runGlobalOptimizations()
+
         while (true) {
           val item = q2.poll
           if (item.isPoison) {
@@ -269,7 +284,12 @@ abstract class GenBCode extends BCodeSyncAndTry {
 
     var arrivalPos = 0
 
-    /*
+    /**
+     * The `run` method is overridden because the backend has a different data flow than the default
+     * phase: the backend does not transform compilation units one by one, but on all units in the
+     * same run. This allows cross-unit optimizations and running some stages of the backend
+     * concurrently on multiple units.
+     *
      *  A run of the BCodePhase phase comprises:
      *
      *    (a) set-up steps (most notably supporting maps in `BCodeTypes`,
@@ -287,6 +307,10 @@ abstract class GenBCode extends BCodeSyncAndTry {
       arrivalPos = 0 // just in case
       scalaPrimitives.init()
       bTypes.initializeCoreBTypes()
+      bTypes.javaDefinedClasses.clear()
+      bTypes.javaDefinedClasses ++= currentRun.symSource collect {
+        case (sym, _) if sym.isJavaDefined => sym.javaBinaryName.toString
+      }
       Statistics.stopTimer(BackendStats.bcodeInitTimer, initStart)
 
       // initBytecodeWriter invokes fullName, thus we have to run it before the typer-dependent thread is activated.
@@ -410,4 +434,7 @@ object GenBCode {
 
   final val PublicStatic      = asm.Opcodes.ACC_PUBLIC | asm.Opcodes.ACC_STATIC
   final val PublicStaticFinal = asm.Opcodes.ACC_PUBLIC | asm.Opcodes.ACC_STATIC | asm.Opcodes.ACC_FINAL
+
+  val CLASS_CONSTRUCTOR_NAME    = "<clinit>"
+  val INSTANCE_CONSTRUCTOR_NAME = "<init>"
 }
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/opt/ByteCodeRepository.scala b/src/compiler/scala/tools/nsc/backend/jvm/opt/ByteCodeRepository.scala
index 7b424d2107..607b7145d6 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/opt/ByteCodeRepository.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/opt/ByteCodeRepository.scala
@@ -10,11 +10,14 @@ package opt
 import scala.tools.asm
 import asm.tree._
 import scala.collection.convert.decorateAsScala._
+import scala.tools.asm.Attribute
+import scala.tools.nsc.backend.jvm.BackendReporting._
 import scala.tools.nsc.io.AbstractFile
 import scala.tools.nsc.util.ClassFileLookup
-import OptimizerReporting._
+import BytecodeUtils._
 import ByteCodeRepository._
 import BTypes.InternalName
+import java.util.concurrent.atomic.AtomicLong
 
 /**
  * The ByteCodeRepository provides utilities to read the bytecode of classfiles from the compilation
@@ -24,58 +27,125 @@ import BTypes.InternalName
  * @param classes   Cache for parsed ClassNodes. Also stores the source of the bytecode:
  *                  [[Classfile]] if read from `classPath`, [[CompilationUnit]] if the bytecode
  *                  corresponds to a class being compiled.
+ *                  The `Long` field encodes the age of the node in the map, which allows removing
+ *                  old entries when the map grows too large.
+ *                  For Java classes in mixed compilation, the map contains an error message: no
+ *                  ClassNode is generated by the backend and also no classfile that could be parsed.
  */
-class ByteCodeRepository(val classPath: ClassFileLookup[AbstractFile], val classes: collection.concurrent.Map[InternalName, (ClassNode, Source)]) {
+class ByteCodeRepository(val classPath: ClassFileLookup[AbstractFile], val isJavaSourceDefined: InternalName => Boolean, val classes: collection.concurrent.Map[InternalName, Either[ClassNotFound, (ClassNode, Source, Long)]]) {
+
+  private val maxCacheSize = 1500
+  private val targetSize   = 500
+
+  private val idCounter = new AtomicLong(0)
+
+  /**
+   * Prevent the code repository from growing too large. Profiling reveals that the average size
+   * of a ClassNode is about 30 kb. I observed having 17k+ classes in the cache, i.e., 500 mb.
+   *
+   * We can only remove classes with `Source == Classfile`, those can be parsed again if requested.
+   */
+  private def limitCacheSize(): Unit = {
+    if (classes.count(c => c._2.isRight && c._2.right.get._2 == Classfile) > maxCacheSize) {
+      val removeId = idCounter.get - targetSize
+      val toRemove = classes.iterator.collect({
+        case (name, Right((_, Classfile, id))) if id < removeId => name
+      }).toList
+      toRemove foreach classes.remove
+    }
+  }
+
+  def add(classNode: ClassNode, source: Source) = {
+    classes(classNode.name) = Right((classNode, source, idCounter.incrementAndGet()))
+  }
+
   /**
    * The class node and source for an internal name. If the class node is not yet available, it is
    * parsed from the classfile on the compile classpath.
    */
-  def classNodeAndSource(internalName: InternalName): (ClassNode, Source) = {
-    classes.getOrElseUpdate(internalName, (parseClass(internalName), Classfile))
+  def classNodeAndSource(internalName: InternalName): Either[ClassNotFound, (ClassNode, Source)] = {
+    val r = classes.getOrElseUpdate(internalName, {
+      limitCacheSize()
+      parseClass(internalName).map((_, Classfile, idCounter.incrementAndGet()))
+    })
+    r.map(v => (v._1, v._2))
   }
 
   /**
    * The class node for an internal name. If the class node is not yet available, it is parsed from
    * the classfile on the compile classpath.
    */
-  def classNode(internalName: InternalName) = classNodeAndSource(internalName)._1
+  def classNode(internalName: InternalName): Either[ClassNotFound, ClassNode] = classNodeAndSource(internalName).map(_._1)
 
   /**
    * The field node for a field matching `name` and `descriptor`, accessed in class `classInternalName`.
    * The declaration of the field may be in one of the superclasses.
    *
-   * @return The [[FieldNode]] of the requested field and the [[InternalName]] of its declaring class.
+   * @return The [[FieldNode]] of the requested field and the [[InternalName]] of its declaring
+   *         class, or an error message if the field could not be found
    */
-  def fieldNode(classInternalName: InternalName, name: String, descriptor: String): Option[(FieldNode, InternalName)] = {
-    val c = classNode(classInternalName)
-    c.fields.asScala.find(f => f.name == name && f.desc == descriptor).map((_, classInternalName)) orElse {
-      Option(c.superName).flatMap(n => fieldNode(n, name, descriptor))
+  def fieldNode(classInternalName: InternalName, name: String, descriptor: String): Either[FieldNotFound, (FieldNode, InternalName)] = {
+    def fieldNodeImpl(parent: InternalName): Either[FieldNotFound, (FieldNode, InternalName)] = {
+      def msg = s"The field node $name$descriptor could not be found in class $classInternalName or any of its superclasses."
+      classNode(parent) match {
+        case Left(e)  => Left(FieldNotFound(name, descriptor, classInternalName, Some(e)))
+        case Right(c) =>
+          c.fields.asScala.find(f => f.name == name && f.desc == descriptor) match {
+            case Some(f) => Right((f, parent))
+            case None    =>
+              if (c.superName == null) Left(FieldNotFound(name, descriptor, classInternalName, None))
+              else fieldNode(c.superName, name, descriptor)
+          }
+      }
     }
+    fieldNodeImpl(classInternalName)
   }
 
   /**
    * The method node for a method matching `name` and `descriptor`, accessed in class `classInternalName`.
    * The declaration of the method may be in one of the parents.
    *
-   * @return The [[MethodNode]] of the requested method and the [[InternalName]] of its declaring class.
+   * @return The [[MethodNode]] of the requested method and the [[InternalName]] of its declaring
+   *         class, or an error message if the method could not be found.
    */
-  def methodNode(classInternalName: InternalName, name: String, descriptor: String): Option[(MethodNode, InternalName)] = {
-    val c = classNode(classInternalName)
-    c.methods.asScala.find(m => m.name == name && m.desc == descriptor).map((_, classInternalName)) orElse {
-      val parents = Option(c.superName) ++ c.interfaces.asScala
-      // `view` to stop at the first result
-      parents.view.flatMap(methodNode(_, name, descriptor)).headOption
+  def methodNode(ownerInternalNameOrArrayDescriptor: String, name: String, descriptor: String): Either[MethodNotFound, (MethodNode, InternalName)] = {
+    // on failure, returns a list of class names that could not be found on the classpath
+    def methodNodeImpl(ownerInternalName: InternalName): Either[List[ClassNotFound], (MethodNode, InternalName)] = {
+      classNode(ownerInternalName) match {
+        case Left(e)  => Left(List(e))
+        case Right(c) =>
+          c.methods.asScala.find(m => m.name == name && m.desc == descriptor) match {
+            case Some(m) => Right((m, ownerInternalName))
+            case None    => findInParents(Option(c.superName) ++: c.interfaces.asScala.toList, Nil)
+          }
+      }
     }
+
+    // find the MethodNode in one of the parent classes
+    def findInParents(parents: List[InternalName], failedClasses: List[ClassNotFound]): Either[List[ClassNotFound], (MethodNode, InternalName)] = parents match {
+      case x :: xs => methodNodeImpl(x).left.flatMap(failed => findInParents(xs, failed ::: failedClasses))
+      case Nil     => Left(failedClasses)
+    }
+
+    // In a MethodInsnNode, the `owner` field may be an array descriptor, for exmple when invoking `clone`. We don't have a method node to return in this case.
+    if (ownerInternalNameOrArrayDescriptor.charAt(0) == '[')
+      Left(MethodNotFound(name, descriptor, ownerInternalNameOrArrayDescriptor, Nil))
+    else
+      methodNodeImpl(ownerInternalNameOrArrayDescriptor).left.map(MethodNotFound(name, descriptor, ownerInternalNameOrArrayDescriptor, _))
   }
 
-  private def parseClass(internalName: InternalName): ClassNode = {
+  private def parseClass(internalName: InternalName): Either[ClassNotFound, ClassNode] = {
     val fullName = internalName.replace('/', '.')
     classPath.findClassFile(fullName) map { classFile =>
       val classNode = new asm.tree.ClassNode()
       val classReader = new asm.ClassReader(classFile.toByteArray)
+
+      // Passing the InlineInfoAttributePrototype makes the ClassReader invoke the specific `read`
+      // method of the InlineInfoAttribute class, instead of putting the byte array into a generic
+      // Attribute.
       // We don't need frames when inlining, but we want to keep the local variable table, so we
       // don't use SKIP_DEBUG.
-      classReader.accept(classNode, asm.ClassReader.SKIP_FRAMES)
+      classReader.accept(classNode, Array[Attribute](InlineInfoAttributePrototype), asm.ClassReader.SKIP_FRAMES)
       // SKIP_FRAMES leaves line number nodes. Remove them because they are not correct after
       // inlining.
       // TODO: we need to remove them also for classes that are not parsed from classfiles, why not simplify and do it once when inlining?
@@ -85,18 +155,9 @@ class ByteCodeRepository(val classPath: ClassFileLookup[AbstractFile], val class
       //   https://jcp.org/aboutJava/communityprocess/final/jsr045/index.html
       removeLineNumberNodes(classNode)
       classNode
-    } getOrElse {
-      inlineFailure(s"Class file for class $fullName not found.")
-    }
-  }
-
-  private def removeLineNumberNodes(classNode: ClassNode): Unit = {
-    for (method <- classNode.methods.asScala) {
-      val iter = method.instructions.iterator()
-      while (iter.hasNext) iter.next() match {
-        case _: LineNumberNode => iter.remove()
-        case _ =>
-      }
+    } match {
+      case Some(node) => Right(node)
+      case None       => Left(ClassNotFound(internalName, isJavaSourceDefined(internalName)))
     }
   }
 }
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/opt/BytecodeUtils.scala b/src/compiler/scala/tools/nsc/backend/jvm/opt/BytecodeUtils.scala
index 6b4047c0a7..14e8cccc60 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/opt/BytecodeUtils.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/opt/BytecodeUtils.scala
@@ -10,9 +10,14 @@ package opt
 import scala.annotation.{tailrec, switch}
 import scala.collection.mutable
 import scala.reflect.internal.util.Collections._
-import scala.tools.asm.Opcodes
+import scala.tools.asm.tree.analysis._
+import scala.tools.asm.{MethodWriter, ClassWriter, Label, Opcodes}
 import scala.tools.asm.tree._
 import scala.collection.convert.decorateAsScala._
+import GenBCode._
+import scala.collection.convert.decorateAsScala._
+import scala.collection.convert.decorateAsJava._
+import scala.tools.nsc.backend.jvm.BTypes._
 
 object BytecodeUtils {
 
@@ -68,6 +73,20 @@ object BytecodeUtils {
 
   def isExecutable(instruction: AbstractInsnNode): Boolean = instruction.getOpcode >= 0
 
+  def isConstructor(methodNode: MethodNode): Boolean = {
+    methodNode.name == INSTANCE_CONSTRUCTOR_NAME || methodNode.name == CLASS_CONSTRUCTOR_NAME
+  }
+
+  def isStaticMethod(methodNode: MethodNode): Boolean = (methodNode.access & Opcodes.ACC_STATIC) != 0
+
+  def isAbstractMethod(methodNode: MethodNode): Boolean = (methodNode.access & Opcodes.ACC_ABSTRACT) != 0
+
+  def isSynchronizedMethod(methodNode: MethodNode): Boolean = (methodNode.access & Opcodes.ACC_SYNCHRONIZED) != 0
+
+  def isFinalClass(classNode: ClassNode): Boolean = (classNode.access & Opcodes.ACC_FINAL) != 0
+
+  def isFinalMethod(methodNode: MethodNode): Boolean = (methodNode.access & (Opcodes.ACC_FINAL | Opcodes.ACC_PRIVATE | Opcodes.ACC_STATIC)) != 0
+
   def nextExecutableInstruction(instruction: AbstractInsnNode, alsoKeep: AbstractInsnNode => Boolean = Set()): Option[AbstractInsnNode] = {
     var result = instruction
     do { result = result.getNext }
@@ -181,4 +200,115 @@ object BytecodeUtils {
         if (handler.end == from) handler.end = to
     }
   }
+
+  /**
+   * In order to run an Analyzer, the maxLocals / maxStack fields need to be available. The ASM
+   * framework only computes these values during bytecode generation.
+   *
+   * Since there's currently no better way, we run a bytecode generator on the method and extract
+   * the computed values. This required changes to the ASM codebase:
+   *   - the [[MethodWriter]] class was made public
+   *   - accessors for maxLocals / maxStack were added to the MethodWriter class
+   *
+   * We could probably make this faster (and allocate less memory) by hacking the ASM framework
+   * more: create a subclass of MethodWriter with a /dev/null byteVector. Another option would be
+   * to create a separate visitor for computing those values, duplicating the functionality from the
+   * MethodWriter.
+   */
+  def computeMaxLocalsMaxStack(method: MethodNode) {
+    val cw = new ClassWriter(ClassWriter.COMPUTE_MAXS)
+    val excs = method.exceptions.asScala.toArray
+    val mw = cw.visitMethod(method.access, method.name, method.desc, method.signature, excs).asInstanceOf[MethodWriter]
+    method.accept(mw)
+    method.maxLocals = mw.getMaxLocals
+    method.maxStack = mw.getMaxStack
+  }
+
+  def removeLineNumberNodes(classNode: ClassNode): Unit = {
+    for (m <- classNode.methods.asScala) removeLineNumberNodes(m.instructions)
+  }
+
+  def removeLineNumberNodes(instructions: InsnList): Unit = {
+    val iter = instructions.iterator()
+    while (iter.hasNext) iter.next() match {
+      case _: LineNumberNode => iter.remove()
+      case _ =>
+    }
+  }
+
+  def cloneLabels(methodNode: MethodNode): Map[LabelNode, LabelNode] = {
+    methodNode.instructions.iterator().asScala.collect({
+      case labelNode: LabelNode => (labelNode, newLabelNode)
+    }).toMap
+  }
+
+  /**
+   * Create a new [[LabelNode]] with a correctly associated [[Label]].
+   */
+  def newLabelNode: LabelNode = {
+    val label = new Label
+    val labelNode = new LabelNode(label)
+    label.info = labelNode
+    labelNode
+  }
+
+  /**
+   * Clone the instructions in `methodNode` into a new [[InsnList]], mapping labels according to
+   * the `labelMap`. Returns the new instruction list and a map from old to new instructions.
+   */
+  def cloneInstructions(methodNode: MethodNode, labelMap: Map[LabelNode, LabelNode]): (InsnList, Map[AbstractInsnNode, AbstractInsnNode]) = {
+    val javaLabelMap = labelMap.asJava
+    val result = new InsnList
+    var map = Map.empty[AbstractInsnNode, AbstractInsnNode]
+    for (ins <- methodNode.instructions.iterator.asScala) {
+      val cloned = ins.clone(javaLabelMap)
+      result add cloned
+      map += ((ins, cloned))
+    }
+    (result, map)
+  }
+
+  /**
+   * Clone the local variable descriptors of `methodNode` and map their `start` and `end` labels
+   * according to the `labelMap`.
+   */
+  def cloneLocalVariableNodes(methodNode: MethodNode, labelMap: Map[LabelNode, LabelNode], prefix: String): List[LocalVariableNode] = {
+    methodNode.localVariables.iterator().asScala.map(localVariable => new LocalVariableNode(
+      prefix + localVariable.name,
+      localVariable.desc,
+      localVariable.signature,
+      labelMap(localVariable.start),
+      labelMap(localVariable.end),
+      localVariable.index
+    )).toList
+  }
+
+  /**
+   * Clone the local try/catch blocks of `methodNode` and map their `start` and `end` and `handler`
+   * labels according to the `labelMap`.
+   */
+  def cloneTryCatchBlockNodes(methodNode: MethodNode, labelMap: Map[LabelNode, LabelNode]): List[TryCatchBlockNode] = {
+    methodNode.tryCatchBlocks.iterator().asScala.map(tryCatch => new TryCatchBlockNode(
+      labelMap(tryCatch.start),
+      labelMap(tryCatch.end),
+      labelMap(tryCatch.handler),
+      tryCatch.`type`
+    )).toList
+  }
+
+  /**
+   * A wrapper to make ASM's Analyzer a bit easier to use.
+   */
+  class AsmAnalyzer[V <: Value](methodNode: MethodNode, classInternalName: InternalName, interpreter: Interpreter[V] = new BasicInterpreter) {
+    val analyzer = new Analyzer(interpreter)
+    analyzer.analyze(classInternalName, methodNode)
+    def frameAt(instruction: AbstractInsnNode): Frame[V] = analyzer.getFrames()(methodNode.instructions.indexOf(instruction))
+  }
+
+  implicit class `frame extensions`[V <: Value](val frame: Frame[V]) extends AnyVal {
+    def peekDown(n: Int): V = {
+      val topIndex = frame.getStackSize - 1
+      frame.getStack(topIndex - n)
+    }
+  }
 }
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/opt/CallGraph.scala b/src/compiler/scala/tools/nsc/backend/jvm/opt/CallGraph.scala
new file mode 100644
index 0000000000..47d32c94cb
--- /dev/null
+++ b/src/compiler/scala/tools/nsc/backend/jvm/opt/CallGraph.scala
@@ -0,0 +1,189 @@
+/* NSC -- new Scala compiler
+ * Copyright 2005-2014 LAMP/EPFL
+ * @author  Martin Odersky
+ */
+
+package scala.tools.nsc
+package backend.jvm
+package opt
+
+import scala.reflect.internal.util.{NoPosition, Position}
+import scala.tools.asm.tree._
+import scala.collection.convert.decorateAsScala._
+import scala.tools.nsc.backend.jvm.BTypes.{MethodInlineInfo, InternalName}
+import scala.tools.nsc.backend.jvm.BackendReporting._
+import scala.tools.nsc.backend.jvm.opt.BytecodeUtils.AsmAnalyzer
+import ByteCodeRepository.{Source, CompilationUnit}
+
+class CallGraph[BT <: BTypes](val btypes: BT) {
+  import btypes._
+
+  val callsites: collection.concurrent.Map[MethodInsnNode, Callsite] = recordPerRunCache(collection.concurrent.TrieMap.empty[MethodInsnNode, Callsite])
+
+  def addClass(classNode: ClassNode): Unit = {
+    for (m <- classNode.methods.asScala; callsite <- analyzeCallsites(m, classBTypeFromClassNode(classNode)))
+      callsites(callsite.callsiteInstruction) = callsite
+  }
+
+  def analyzeCallsites(methodNode: MethodNode, definingClass: ClassBType): List[Callsite] = {
+
+    case class CallsiteInfo(safeToInline: Boolean, safeToRewrite: Boolean,
+                            annotatedInline: Boolean, annotatedNoInline: Boolean,
+                            warning: Option[CalleeInfoWarning])
+
+    /**
+     * Analyze a callsite and gather meta-data that can be used for inlining decisions.
+     */
+    def analyzeCallsite(calleeMethodNode: MethodNode, calleeDeclarationClassBType: ClassBType, receiverTypeInternalName: InternalName, calleeSource: Source): CallsiteInfo = {
+      val methodSignature = calleeMethodNode.name + calleeMethodNode.desc
+
+      try {
+        // The inlineInfo.methodInfos of a ClassBType holds an InlineInfo for each method *declared*
+        // within a class (not for inherited methods). Since we already have the  classBType of the
+        // callee, we only check there for the methodInlineInfo, we should find it there.
+        calleeDeclarationClassBType.info.orThrow.inlineInfo.methodInfos.get(methodSignature) match {
+          case Some(methodInlineInfo) =>
+            val canInlineFromSource = inlineGlobalEnabled || calleeSource == CompilationUnit
+
+            val isAbstract = BytecodeUtils.isAbstractMethod(calleeMethodNode)
+
+            // (1) A non-final method can be safe to inline if the receiver type is a final subclass. Example:
+            //   class A { @inline def f = 1 }; object B extends A; B.f  // can be inlined
+            //
+            // TODO: type analysis can render more calls statically resolved. Example˜∫
+            //   new A.f  // can be inlined, the receiver type is known to be exactly A.
+            val isStaticallyResolved: Boolean = {
+              methodInlineInfo.effectivelyFinal ||
+                classBTypeFromParsedClassfile(receiverTypeInternalName).info.orThrow.inlineInfo.isEffectivelyFinal // (1)
+            }
+
+            val isRewritableTraitCall = isStaticallyResolved && methodInlineInfo.traitMethodWithStaticImplementation
+
+            val warning = calleeDeclarationClassBType.info.orThrow.inlineInfo.warning.map(
+              MethodInlineInfoIncomplete(calleeDeclarationClassBType.internalName, calleeMethodNode.name, calleeMethodNode.desc, _))
+
+            // (1) For invocations of final trait methods, the callee isStaticallyResolved but also
+            //     abstract. Such a callee is not safe to inline - it needs to be re-written to the
+            //     static impl method first (safeToRewrite).
+            // (2) Final trait methods can be rewritten from the interface to the static implementation
+            //     method to enable inlining.
+            CallsiteInfo(
+              safeToInline      = canInlineFromSource && isStaticallyResolved && !isAbstract, // (1)
+              safeToRewrite     = canInlineFromSource && isRewritableTraitCall,               // (2)
+              annotatedInline   = methodInlineInfo.annotatedInline,
+              annotatedNoInline = methodInlineInfo.annotatedNoInline,
+              warning           = warning)
+
+          case None =>
+            val warning = MethodInlineInfoMissing(calleeDeclarationClassBType.internalName, calleeMethodNode.name, calleeMethodNode.desc, calleeDeclarationClassBType.info.orThrow.inlineInfo.warning)
+            CallsiteInfo(false, false, false, false, Some(warning))
+        }
+      } catch {
+        case Invalid(noInfo: NoClassBTypeInfo) =>
+          val warning = MethodInlineInfoError(calleeDeclarationClassBType.internalName, calleeMethodNode.name, calleeMethodNode.desc, noInfo)
+          CallsiteInfo(false, false, false, false, Some(warning))
+      }
+    }
+
+    // TODO: run dataflow analyses to make the call graph more precise
+    //  - producers to get forwarded parameters (ForwardedParam)
+    //  - typeAnalysis for more precise argument types, more precise callee
+    //  - nullAnalysis to skip emitting the receiver-null-check when inlining
+
+    // TODO: for now we run a basic analyzer to get the stack height at the call site.
+    // once we run a more elaborate analyzer (types, nullness), we can get the stack height out of there.
+    val analyzer = new AsmAnalyzer(methodNode, definingClass.internalName)
+
+    methodNode.instructions.iterator.asScala.collect({
+      case call: MethodInsnNode =>
+        val callee: Either[OptimizerWarning, Callee] = for {
+          (method, declarationClass)     <- byteCodeRepository.methodNode(call.owner, call.name, call.desc): Either[OptimizerWarning, (MethodNode, InternalName)]
+          (declarationClassNode, source) <- byteCodeRepository.classNodeAndSource(declarationClass): Either[OptimizerWarning, (ClassNode, Source)]
+          declarationClassBType          =  classBTypeFromClassNode(declarationClassNode)
+        } yield {
+          val CallsiteInfo(safeToInline, safeToRewrite, annotatedInline, annotatedNoInline, warning) = analyzeCallsite(method, declarationClassBType, call.owner, source)
+          Callee(
+            callee = method,
+            calleeDeclarationClass = declarationClassBType,
+            safeToInline = safeToInline,
+            safeToRewrite = safeToRewrite,
+            annotatedInline = annotatedInline,
+            annotatedNoInline = annotatedNoInline,
+            calleeInfoWarning = warning)
+        }
+
+        val argInfos = if (callee.isLeft) Nil else {
+          // TODO: for now it's Nil, because we don't run any data flow analysis
+          // there's no point in using the parameter types, that doesn't add any information.
+          // NOTE: need to run the same analyses after inlining, to re-compute the argInfos for the
+          // new duplicated callsites, see Inliner.inline
+          Nil
+        }
+
+        Callsite(
+          callsiteInstruction = call,
+          callsiteMethod = methodNode,
+          callsiteClass = definingClass,
+          callee = callee,
+          argInfos = argInfos,
+          callsiteStackHeight = analyzer.frameAt(call).getStackSize,
+          callsitePosition = callsitePositions.getOrElse(call, NoPosition)
+        )
+    }).toList
+  }
+
+  /**
+   * A callsite in the call graph.
+   *
+   * @param callsiteInstruction The invocation instruction
+   * @param callsiteMethod      The method containing the callsite
+   * @param callsiteClass       The class containing the callsite
+   * @param callee              The callee, as it appears in the invocation instruction. For virtual
+   *                            calls, an override of the callee might be invoked. Also, the callee
+   *                            can be abstract. Contains a warning message if the callee MethodNode
+   *                            cannot be found in the bytecode repository.
+   * @param argInfos            Information about the invocation receiver and arguments
+   * @param callsiteStackHeight The stack height at the callsite, required by the inliner
+   * @param callsitePosition    The source position of the callsite, used for inliner warnings.
+   */
+  final case class Callsite(callsiteInstruction: MethodInsnNode, callsiteMethod: MethodNode, callsiteClass: ClassBType,
+                            callee: Either[OptimizerWarning, Callee], argInfos: List[ArgInfo],
+                            callsiteStackHeight: Int, callsitePosition: Position) {
+    override def toString =
+      "Invocation of" +
+        s" ${callee.map(_.calleeDeclarationClass.internalName).getOrElse("?")}.${callsiteInstruction.name + callsiteInstruction.desc}" +
+        s"@${callsiteMethod.instructions.indexOf(callsiteInstruction)}" +
+        s" in ${callsiteClass.internalName}.${callsiteMethod.name}"
+  }
+
+  /**
+   * Information about invocation arguments, obtained through data flow analysis of the callsite method.
+   */
+  sealed trait ArgInfo
+  final case class ArgTypeInfo(argType: BType, isPrecise: Boolean, knownNotNull: Boolean) extends ArgInfo
+  final case class ForwardedParam(index: Int) extends ArgInfo
+  // can be extended, e.g., with constant types
+
+  /**
+   * A callee in the call graph.
+   *
+   * @param callee                 The callee, as it appears in the invocation instruction. For
+   *                               virtual calls, an override of the callee might be invoked. Also,
+   *                               the callee can be abstract.
+   * @param calleeDeclarationClass The class in which the callee is declared
+   * @param safeToInline           True if the callee can be safely inlined: it cannot be overridden,
+   *                               and the inliner settings (project / global) allow inlining it.
+   * @param safeToRewrite          True if the callee the interface method of a concrete trait method
+   *                               that can be safely re-written to the static implementation method.
+   * @param annotatedInline        True if the callee is annotated @inline
+   * @param annotatedNoInline      True if the callee is annotated @noinline
+   * @param calleeInfoWarning      An inliner warning if some information was not available while
+   *                               gathering the information about this callee.
+   */
+  final case class Callee(callee: MethodNode, calleeDeclarationClass: ClassBType,
+                          safeToInline: Boolean, safeToRewrite: Boolean,
+                          annotatedInline: Boolean, annotatedNoInline: Boolean,
+                          calleeInfoWarning: Option[CalleeInfoWarning]) {
+    assert(!(safeToInline && safeToRewrite), s"A callee of ${callee.name} can be either safeToInline or safeToRewrite, but not both.")
+  }
+}
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/opt/InlineInfoAttribute.scala b/src/compiler/scala/tools/nsc/backend/jvm/opt/InlineInfoAttribute.scala
index 4812f2290f..e7dd5abc57 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/opt/InlineInfoAttribute.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/opt/InlineInfoAttribute.scala
@@ -9,6 +9,7 @@ package opt
 
 import scala.tools.asm._
 import scala.tools.nsc.backend.jvm.BTypes.{InlineInfo, MethodInlineInfo}
+import scala.tools.nsc.backend.jvm.BackendReporting.UnknownScalaInlineInfoVersion
 
 /**
  * This attribute stores the InlineInfo for a ClassBType as an independent classfile attribute.
@@ -119,7 +120,7 @@ case class InlineInfoAttribute(inlineInfo: InlineInfo) extends Attribute(InlineI
 
       InlineInfoAttribute(InlineInfo(self, isFinal, infos, None))
     } else {
-      val msg = s"Cannot read ScalaInlineInfo version $version in classfile ${cr.getClassName}. Use a more recent compiler."
+      val msg = UnknownScalaInlineInfoVersion(cr.getClassName, version)
       InlineInfoAttribute(BTypes.EmptyInlineInfo.copy(warning = Some(msg)))
     }
   }
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/opt/Inliner.scala b/src/compiler/scala/tools/nsc/backend/jvm/opt/Inliner.scala
new file mode 100644
index 0000000000..e14e57d3ab
--- /dev/null
+++ b/src/compiler/scala/tools/nsc/backend/jvm/opt/Inliner.scala
@@ -0,0 +1,648 @@
+/* NSC -- new Scala compiler
+ * Copyright 2005-2014 LAMP/EPFL
+ * @author  Martin Odersky
+ */
+
+package scala.tools.nsc
+package backend.jvm
+package opt
+
+import scala.annotation.tailrec
+import scala.tools.asm
+import asm.Opcodes._
+import asm.tree._
+import scala.collection.convert.decorateAsScala._
+import scala.collection.convert.decorateAsJava._
+import AsmUtils._
+import BytecodeUtils._
+import collection.mutable
+import scala.tools.asm.tree.analysis.{SourceInterpreter, Analyzer}
+import BackendReporting._
+import scala.tools.nsc.backend.jvm.BTypes.InternalName
+
+class Inliner[BT <: BTypes](val btypes: BT) {
+  import btypes._
+  import callGraph._
+
+  def runInliner(): Unit = {
+    rewriteFinalTraitMethodInvocations()
+
+    for (request <- collectAndOrderInlineRequests) {
+      val Right(callee) = request.callee // collectAndOrderInlineRequests returns callsites with a known callee
+
+      val r = inline(request.callsiteInstruction, request.callsiteStackHeight, request.callsiteMethod, request.callsiteClass,
+        callee.callee, callee.calleeDeclarationClass,
+        receiverKnownNotNull = false, keepLineNumbers = false)
+
+      for (warning <- r) {
+        if ((callee.annotatedInline && btypes.warnSettings.atInlineFailed) || warning.emitWarning(warnSettings)) {
+          val annotWarn = if (callee.annotatedInline) " is annotated @inline but" else ""
+          val msg = s"${BackendReporting.methodSignature(callee.calleeDeclarationClass.internalName, callee.callee)}$annotWarn could not be inlined:\n$warning"
+          backendReporting.inlinerWarning(request.callsitePosition, msg)
+        }
+      }
+    }
+  }
+
+  /**
+   * Ordering for inline requests. Required to make the inliner deterministic:
+   *   - Always remove the same request when breaking inlining cycles
+   *   - Perform inlinings in a consistent order
+   */
+  object callsiteOrdering extends Ordering[Callsite] {
+    override def compare(x: Callsite, y: Callsite): Int = {
+      val cls = x.callsiteClass.internalName compareTo y.callsiteClass.internalName
+      if (cls != 0) return cls
+
+      val name = x.callsiteMethod.name compareTo y.callsiteMethod.name
+      if (name != 0) return name
+
+      val desc = x.callsiteMethod.desc compareTo y.callsiteMethod.desc
+      if (desc != 0) return desc
+
+      def pos(c: Callsite) = c.callsiteMethod.instructions.indexOf(c.callsiteInstruction)
+      pos(x) - pos(y)
+    }
+  }
+
+  /**
+   * Select callsites from the call graph that should be inlined. The resulting list of inlining
+   * requests is allowed to have cycles, and the callsites can appear in any order.
+   */
+  def selectCallsitesForInlining: List[Callsite] = {
+    callsites.valuesIterator.filter({
+      case callsite @ Callsite(_, _, _, Right(Callee(callee, calleeDeclClass, safeToInline, _, annotatedInline, _, warning)), _, _, pos) =>
+        val res = doInlineCallsite(callsite)
+
+        if (!res) {
+          if (annotatedInline && btypes.warnSettings.atInlineFailed) {
+            // if the callsite is annotated @inline, we report an inline warning even if the underlying
+            // reason is, for example, mixed compilation (which has a separate -Yopt-warning flag).
+            def initMsg = s"${BackendReporting.methodSignature(calleeDeclClass.internalName, callee)} is annotated @inline but cannot be inlined"
+            def warnMsg = warning.map(" Possible reason:\n" + _).getOrElse("")
+            if (doRewriteTraitCallsite(callsite))
+              backendReporting.inlinerWarning(pos, s"$initMsg: the trait method call could not be rewritten to the static implementation method." + warnMsg)
+            else if (!safeToInline)
+              backendReporting.inlinerWarning(pos, s"$initMsg: the method is not final and may be overridden." + warnMsg)
+            else
+              backendReporting.inlinerWarning(pos, s"$initMsg." + warnMsg)
+          } else if (warning.isDefined && warning.get.emitWarning(warnSettings)) {
+            // when annotatedInline is false, and there is some warning, the callsite metadata is possibly incomplete.
+            backendReporting.inlinerWarning(pos, s"there was a problem determining if method ${callee.name} can be inlined: \n"+ warning.get)
+          }
+        }
+
+        res
+
+      case Callsite(ins, _, _, Left(warning), _, _, pos) =>
+        if (warning.emitWarning(warnSettings))
+          backendReporting.inlinerWarning(pos, s"failed to determine if ${ins.name} should be inlined:\n$warning")
+        false
+    }).toList
+  }
+
+  /**
+   * The current inlining heuristics are simple: inline calls to methods annotated @inline.
+   */
+  def doInlineCallsite(callsite: Callsite): Boolean = callsite match {
+    case Callsite(_, _, _, Right(Callee(callee, calleeDeclClass, safeToInline, _, annotatedInline, _, warning)), _, _, pos) =>
+      annotatedInline && safeToInline
+
+    case _ => false
+  }
+
+  def rewriteFinalTraitMethodInvocations(): Unit = {
+    // Rewriting final trait method callsites to the implementation class enables inlining.
+    // We cannot just iterate over the values of the `callsites` map because the rewrite changes the
+    // map. Therefore we first copy the values to a list.
+    callsites.values.toList.foreach(rewriteFinalTraitMethodInvocation)
+  }
+
+  /**
+   * True for statically resolved trait callsites that should be rewritten to the static implementation method.
+   */
+  def doRewriteTraitCallsite(callsite: Callsite) = callsite.callee match {
+    case Right(Callee(callee, calleeDeclarationClass, safeToInline, true, annotatedInline, annotatedNoInline, infoWarning)) => true
+    case _ => false
+  }
+
+  /**
+   * Rewrite the INVOKEINTERFACE callsite of a final trait method invocation to INVOKESTATIC of the
+   * corresponding method in the implementation class. This enables inlining final trait methods.
+   *
+   * In a final trait method callsite, the callee is safeToInline and the callee method is abstract
+   * (the receiver type is the interface, so the method is abstract).
+   */
+  def rewriteFinalTraitMethodInvocation(callsite: Callsite): Unit = {
+    if (doRewriteTraitCallsite(callsite)) {
+      val Right(Callee(callee, calleeDeclarationClass, _, _, annotatedInline, annotatedNoInline, infoWarning)) = callsite.callee
+
+      val traitMethodArgumentTypes = asm.Type.getArgumentTypes(callee.desc)
+
+      val implClassInternalName = calleeDeclarationClass.internalName + "$class"
+
+      val selfParamTypeV: Either[OptimizerWarning, ClassBType] = calleeDeclarationClass.info.map(_.inlineInfo.traitImplClassSelfType match {
+        case Some(internalName) => classBTypeFromParsedClassfile(internalName)
+        case None               => calleeDeclarationClass
+      })
+
+      def implClassMethodV(implMethodDescriptor: String): Either[OptimizerWarning, MethodNode] = {
+        byteCodeRepository.methodNode(implClassInternalName, callee.name, implMethodDescriptor).map(_._1)
+      }
+
+      // The rewrite reading the implementation class and the implementation method from the bytecode
+      // repository. If either of the two fails, the rewrite is not performed.
+      val res = for {
+        selfParamType        <- selfParamTypeV
+        implMethodDescriptor =  asm.Type.getMethodDescriptor(asm.Type.getReturnType(callee.desc), selfParamType.toASMType +: traitMethodArgumentTypes: _*)
+        implClassMethod      <- implClassMethodV(implMethodDescriptor)
+        implClassBType       =  classBTypeFromParsedClassfile(implClassInternalName)
+        selfTypeOk           <- calleeDeclarationClass.isSubtypeOf(selfParamType)
+      } yield {
+
+        // The self parameter type may be incompatible with the trait type.
+        //   trait T { self: S => def foo = 1 }
+        // The $self parameter type of T$class.foo is S, which may be unrelated to T. If we re-write
+        // a call to T.foo to T$class.foo, we need to cast the receiver to S, otherwise we get a
+        // VerifyError. We run a `SourceInterpreter` to find all producer instructions of the
+        // receiver value and add a cast to the self type after each.
+        if (!selfTypeOk) {
+          val analyzer = new AsmAnalyzer(callsite.callsiteMethod, callsite.callsiteClass.internalName, new SourceInterpreter)
+          val receiverValue = analyzer.frameAt(callsite.callsiteInstruction).peekDown(traitMethodArgumentTypes.length)
+          for (i <- receiverValue.insns.asScala) {
+            val cast = new TypeInsnNode(CHECKCAST, selfParamType.internalName)
+            callsite.callsiteMethod.instructions.insert(i, cast)
+          }
+        }
+
+        val newCallsiteInstruction = new MethodInsnNode(INVOKESTATIC, implClassInternalName, callee.name, implMethodDescriptor, false)
+        callsite.callsiteMethod.instructions.insert(callsite.callsiteInstruction, newCallsiteInstruction)
+        callsite.callsiteMethod.instructions.remove(callsite.callsiteInstruction)
+
+        callGraph.callsites.remove(callsite.callsiteInstruction)
+        val staticCallsite = Callsite(
+          callsiteInstruction = newCallsiteInstruction,
+          callsiteMethod      = callsite.callsiteMethod,
+          callsiteClass       = callsite.callsiteClass,
+          callee              = Right(Callee(
+            callee                 = implClassMethod,
+            calleeDeclarationClass = implClassBType,
+            safeToInline           = true,
+            safeToRewrite          = false,
+            annotatedInline        = annotatedInline,
+            annotatedNoInline      = annotatedNoInline,
+            calleeInfoWarning      = infoWarning)),
+          argInfos            = Nil,
+          callsiteStackHeight = callsite.callsiteStackHeight,
+          callsitePosition = callsite.callsitePosition
+        )
+        callGraph.callsites(newCallsiteInstruction) = staticCallsite
+      }
+
+      for (warning <- res.left) {
+        val Right(callee) = callsite.callee
+        val newCallee = callee.copy(calleeInfoWarning = Some(RewriteTraitCallToStaticImplMethodFailed(calleeDeclarationClass.internalName, callee.callee.name, callee.callee.desc, warning)))
+        callGraph.callsites(callsite.callsiteInstruction) = callsite.copy(callee = Right(newCallee))
+      }
+    }
+  }
+
+  /**
+   * Returns the callsites that can be inlined. Ensures that the returned inline request graph does
+   * not contain cycles.
+   *
+   * The resulting list is sorted such that the leaves of the inline request graph are on the left.
+   * Once these leaves are inlined, the successive elements will be leaves, etc.
+   */
+  private def collectAndOrderInlineRequests: List[Callsite] = {
+    val requests = selectCallsitesForInlining
+
+    // This map is an index to look up the inlining requests for a method. The value sets are mutable
+    // to allow removing elided requests (to break inlining cycles). The map itself is mutable to
+    // allow efficient building: requests.groupBy would build values as List[Callsite] that need to
+    // be transformed to mutable sets.
+    val inlineRequestsForMethod: mutable.Map[MethodNode, mutable.Set[Callsite]] = mutable.HashMap.empty.withDefaultValue(mutable.HashSet.empty)
+    for (r <- requests) inlineRequestsForMethod.getOrElseUpdate(r.callsiteMethod, mutable.HashSet.empty) += r
+
+    /**
+     * Break cycles in the inline request graph by removing callsites.
+     *
+     * The list `requests` is traversed left-to-right, removing those callsites that are part of a
+     * cycle. Elided callsites are also removed from the `inlineRequestsForMethod` map.
+     */
+    def breakInlineCycles(requests: List[Callsite]): List[Callsite] = {
+      // is there a path of inline requests from start to goal?
+      def isReachable(start: MethodNode, goal: MethodNode): Boolean = {
+        @tailrec def reachableImpl(check: List[MethodNode], visited: Set[MethodNode]): Boolean = check match {
+          case x :: xs =>
+            if (x == goal) true
+            else if (visited(x)) reachableImpl(xs, visited)
+            else {
+              val callees = inlineRequestsForMethod(x).map(_.callee.get.callee)
+              reachableImpl(xs ::: callees.toList, visited + x)
+            }
+
+          case Nil =>
+            false
+        }
+        reachableImpl(List(start), Set.empty)
+      }
+
+      val result = new mutable.ListBuffer[Callsite]()
+      // sort the inline requests to ensure that removing requests is deterministic
+      for (r <- requests.sorted(callsiteOrdering)) {
+        // is there a chain of inlining requests that would inline the callsite method into the callee?
+        if (isReachable(r.callee.get.callee, r.callsiteMethod))
+          inlineRequestsForMethod(r.callsiteMethod) -= r
+        else
+          result += r
+      }
+      result.toList
+    }
+
+    // sort the remaining inline requests such that the leaves appear first, then those requests
+    // that become leaves, etc.
+    def leavesFirst(requests: List[Callsite], visited: Set[Callsite] = Set.empty): List[Callsite] = {
+      if (requests.isEmpty) Nil
+      else {
+        val (leaves, others) = requests.partition(r => {
+          val inlineRequestsForCallee = inlineRequestsForMethod(r.callee.get.callee)
+          inlineRequestsForCallee.forall(visited)
+        })
+        assert(leaves.nonEmpty, requests)
+        leaves ::: leavesFirst(others, visited ++ leaves)
+      }
+    }
+
+    leavesFirst(breakInlineCycles(requests))
+  }
+
+
+  /**
+   * Copy and adapt the instructions of a method to a callsite.
+   *
+   * Preconditions:
+   *   - The maxLocals and maxStack values of the callsite method are correctly computed
+   *   - The callsite method contains no unreachable basic blocks, i.e., running an [[Analyzer]]
+   *     does not produce any `null` frames
+   *
+   * @param callsiteInstruction     The invocation instruction
+   * @param callsiteStackHeight     The stack height at the callsite
+   * @param callsiteMethod          The method in which the invocation occurs
+   * @param callsiteClass           The class in which the callsite method is defined
+   * @param callee                  The invoked method
+   * @param calleeDeclarationClass  The class in which the invoked method is defined
+   * @param receiverKnownNotNull    `true` if the receiver is known to be non-null
+   * @param keepLineNumbers         `true` if LineNumberNodes should be copied to the call site
+   * @return                        `Some(message)` if inlining cannot be performed, `None` otherwise
+   */
+  def inline(callsiteInstruction: MethodInsnNode, callsiteStackHeight: Int, callsiteMethod: MethodNode, callsiteClass: ClassBType,
+             callee: MethodNode, calleeDeclarationClass: ClassBType,
+             receiverKnownNotNull: Boolean, keepLineNumbers: Boolean): Option[CannotInlineWarning] = {
+    canInline(callsiteInstruction, callsiteStackHeight, callsiteMethod, callsiteClass, callee, calleeDeclarationClass) orElse {
+      // New labels for the cloned instructions
+      val labelsMap = cloneLabels(callee)
+      val (clonedInstructions, instructionMap) = cloneInstructions(callee, labelsMap)
+      if (!keepLineNumbers) {
+        removeLineNumberNodes(clonedInstructions)
+      }
+
+      // local vars in the callee are shifted by the number of locals at the callsite
+      val localVarShift = callsiteMethod.maxLocals
+      clonedInstructions.iterator.asScala foreach {
+        case varInstruction: VarInsnNode => varInstruction.`var` += localVarShift
+        case _ => ()
+      }
+
+      // add a STORE instruction for each expected argument, including for THIS instance if any
+      val argStores = new InsnList
+      var nextLocalIndex = callsiteMethod.maxLocals
+      if (!isStaticMethod(callee)) {
+        if (!receiverKnownNotNull) {
+          argStores.add(new InsnNode(DUP))
+          val nonNullLabel = newLabelNode
+          argStores.add(new JumpInsnNode(IFNONNULL, nonNullLabel))
+          argStores.add(new InsnNode(ACONST_NULL))
+          argStores.add(new InsnNode(ATHROW))
+          argStores.add(nonNullLabel)
+        }
+        argStores.add(new VarInsnNode(ASTORE, nextLocalIndex))
+        nextLocalIndex += 1
+      }
+
+      // We just use an asm.Type here, no need to create the MethodBType.
+      val calleAsmType = asm.Type.getMethodType(callee.desc)
+
+      for(argTp <- calleAsmType.getArgumentTypes) {
+        val opc = argTp.getOpcode(ISTORE) // returns the correct xSTORE instruction for argTp
+        argStores.insert(new VarInsnNode(opc, nextLocalIndex)) // "insert" is "prepend" - the last argument is on the top of the stack
+        nextLocalIndex += argTp.getSize
+      }
+
+      clonedInstructions.insert(argStores)
+
+      // label for the exit of the inlined functions. xRETURNs are rplaced by GOTOs to this label.
+      val postCallLabel = newLabelNode
+      clonedInstructions.add(postCallLabel)
+
+      // replace xRETURNs:
+      //   - store the return value (if any)
+      //   - clear the stack of the inlined method (insert DROPs)
+      //   - load the return value
+      //   - GOTO postCallLabel
+
+      val returnType = calleAsmType.getReturnType
+      val hasReturnValue = returnType.getSort != asm.Type.VOID
+      val returnValueIndex = callsiteMethod.maxLocals + callee.maxLocals
+      nextLocalIndex += returnType.getSize
+
+      def returnValueStore(returnInstruction: AbstractInsnNode) = {
+        val opc = returnInstruction.getOpcode match {
+          case IRETURN => ISTORE
+          case LRETURN => LSTORE
+          case FRETURN => FSTORE
+          case DRETURN => DSTORE
+          case ARETURN => ASTORE
+        }
+        new VarInsnNode(opc, returnValueIndex)
+      }
+
+      // We run an interpreter to know the stack height at each xRETURN instruction and the sizes
+      // of the values on the stack.
+      val analyzer = new AsmAnalyzer(callee, calleeDeclarationClass.internalName)
+
+      for (originalReturn <- callee.instructions.iterator().asScala if isReturn(originalReturn)) {
+        val frame = analyzer.frameAt(originalReturn)
+        var stackHeight = frame.getStackSize
+
+        val inlinedReturn = instructionMap(originalReturn)
+        val returnReplacement = new InsnList
+
+        def drop(slot: Int) = returnReplacement add getPop(frame.peekDown(slot).getSize)
+
+        // for non-void methods, store the stack top into the return local variable
+        if (hasReturnValue) {
+          returnReplacement add returnValueStore(originalReturn)
+          stackHeight -= 1
+        }
+
+        // drop the rest of the stack
+        for (i <- 0 until stackHeight) drop(i)
+
+        returnReplacement add new JumpInsnNode(GOTO, postCallLabel)
+        clonedInstructions.insert(inlinedReturn, returnReplacement)
+        clonedInstructions.remove(inlinedReturn)
+      }
+
+      // Load instruction for the return value
+      if (hasReturnValue) {
+        val retVarLoad = {
+          val opc = returnType.getOpcode(ILOAD)
+          new VarInsnNode(opc, returnValueIndex)
+        }
+        clonedInstructions.insert(postCallLabel, retVarLoad)
+      }
+
+      callsiteMethod.instructions.insert(callsiteInstruction, clonedInstructions)
+      callsiteMethod.instructions.remove(callsiteInstruction)
+
+      callsiteMethod.localVariables.addAll(cloneLocalVariableNodes(callee, labelsMap, callee.name + "_").asJava)
+      callsiteMethod.tryCatchBlocks.addAll(cloneTryCatchBlockNodes(callee, labelsMap).asJava)
+
+      // Add all invocation instructions that were inlined to the call graph
+      callee.instructions.iterator().asScala foreach {
+        case originalCallsiteIns: MethodInsnNode =>
+          callGraph.callsites.get(originalCallsiteIns) match {
+            case Some(originalCallsite) =>
+              val newCallsiteIns = instructionMap(originalCallsiteIns).asInstanceOf[MethodInsnNode]
+              callGraph.callsites(newCallsiteIns) = Callsite(
+                callsiteInstruction = newCallsiteIns,
+                callsiteMethod = callsiteMethod,
+                callsiteClass = callsiteClass,
+                callee = originalCallsite.callee,
+                argInfos = Nil, // TODO: re-compute argInfos for new destination (once we actually compute them)
+                callsiteStackHeight = callsiteStackHeight + originalCallsite.callsiteStackHeight,
+                callsitePosition = originalCallsite.callsitePosition
+              )
+
+            case None =>
+          }
+
+        case _ =>
+      }
+      // Remove the elided invocation from the call graph
+      callGraph.callsites.remove(callsiteInstruction)
+
+      callsiteMethod.maxLocals += returnType.getSize + callee.maxLocals
+      callsiteMethod.maxStack = math.max(callsiteMethod.maxStack, callee.maxStack + callsiteStackHeight)
+
+      None
+    }
+  }
+
+  /**
+   * Check whether an inling can be performed. Parmeters are described in method [[inline]].
+   * @return `Some(message)` if inlining cannot be performed, `None` otherwise
+   */
+  def canInline(callsiteInstruction: MethodInsnNode, callsiteStackHeight: Int, callsiteMethod: MethodNode, callsiteClass: ClassBType,
+                callee: MethodNode, calleeDeclarationClass: ClassBType): Option[CannotInlineWarning] = {
+
+    def calleeDesc = s"${callee.name} of type ${callee.desc} in ${calleeDeclarationClass.internalName}"
+    def methodMismatch = s"Wrong method node for inlining ${textify(callsiteInstruction)}: $calleeDesc"
+    assert(callsiteInstruction.name == callee.name, methodMismatch)
+    assert(callsiteInstruction.desc == callee.desc, methodMismatch)
+    assert(!isConstructor(callee), s"Constructors cannot be inlined: $calleeDesc")
+    assert(!BytecodeUtils.isAbstractMethod(callee), s"Callee is abstract: $calleeDesc")
+    assert(callsiteMethod.instructions.contains(callsiteInstruction), s"Callsite ${textify(callsiteInstruction)} is not an instruction of $calleeDesc")
+
+    // When an exception is thrown, the stack is cleared before jumping to the handler. When
+    // inlining a method that catches an exception, all values that were on the stack before the
+    // call (in addition to the arguments) would be cleared (SI-6157). So we don't inline methods
+    // with handlers in case there are values on the stack.
+    // Alternatively, we could save all stack values below the method arguments into locals, but
+    // that would be inefficient: we'd need to pop all parameters, save the values, and push the
+    // parameters back for the (inlined) invocation. Similarly for the result after the call.
+    def stackHasNonParameters: Boolean = {
+      val expectedArgs = asm.Type.getArgumentTypes(callsiteInstruction.desc).length + (callsiteInstruction.getOpcode match {
+        case INVOKEVIRTUAL | INVOKESPECIAL | INVOKEINTERFACE => 1
+        case INVOKESTATIC => 0
+        case INVOKEDYNAMIC =>
+          assertionError(s"Unexpected opcode, cannot inline ${textify(callsiteInstruction)}")
+      })
+      callsiteStackHeight > expectedArgs
+    }
+
+    if (isSynchronizedMethod(callee)) {
+      // Could be done by locking on the receiver, wrapping the inlined code in a try and unlocking
+      // in finally. But it's probably not worth the effort, scala never emits synchronized methods.
+      Some(SynchronizedMethod(calleeDeclarationClass.internalName, callee.name, callee.desc))
+    } else if (!callee.tryCatchBlocks.isEmpty && stackHasNonParameters) {
+      Some(MethodWithHandlerCalledOnNonEmptyStack(
+        calleeDeclarationClass.internalName, callee.name, callee.desc,
+        callsiteClass.internalName, callsiteMethod.name, callsiteMethod.desc))
+    } else findIllegalAccess(callee.instructions, calleeDeclarationClass, callsiteClass) map {
+      case (illegalAccessIns, None) =>
+        IllegalAccessInstruction(
+          calleeDeclarationClass.internalName, callee.name, callee.desc,
+          callsiteClass.internalName, illegalAccessIns)
+
+      case (illegalAccessIns, Some(warning)) =>
+        IllegalAccessCheckFailed(
+          calleeDeclarationClass.internalName, callee.name, callee.desc,
+          callsiteClass.internalName, illegalAccessIns, warning)
+    }
+  }
+
+  /**
+   * Returns the first instruction in the `instructions` list that would cause a
+   * [[java.lang.IllegalAccessError]] when inlined into the `destinationClass`.
+   *
+   * If validity of some instruction could not be checked because an error occurred, the instruction
+   * is returned together with a warning message that describes the problem.
+   */
+  def findIllegalAccess(instructions: InsnList, calleeDeclarationClass: ClassBType, destinationClass: ClassBType): Option[(AbstractInsnNode, Option[OptimizerWarning])] = {
+
+    /**
+     * Check if a type is accessible to some class, as defined in JVMS 5.4.4.
+     *  (A1) C is public
+     *  (A2) C and D are members of the same run-time package
+     */
+    def classIsAccessible(accessed: BType, from: ClassBType = destinationClass): Either[OptimizerWarning, Boolean] = (accessed: @unchecked) match {
+      // TODO: A2 requires "same run-time package", which seems to be package + classloader (JMVS 5.3.). is the below ok?
+      case c: ClassBType     => c.isPublic.map(_ || c.packageInternalName == from.packageInternalName)
+      case a: ArrayBType     => classIsAccessible(a.elementType, from)
+      case _: PrimitiveBType => Right(true)
+    }
+
+    /**
+     * Check if a member reference is accessible from the [[destinationClass]], as defined in the
+     * JVMS 5.4.4. Note that the class name in a field / method reference is not necessarily the
+     * class in which the member is declared:
+     *
+     *   class A { def f = 0 }; class B extends A { f }
+     *
+     * The INVOKEVIRTUAL instruction uses a method reference "B.f ()I". Therefore this method has
+     * two parameters:
+     *
+     * @param memberDeclClass The class in which the member is declared (A)
+     * @param memberRefClass  The class used in the member reference (B)
+     *
+     * JVMS 5.4.4 summary: A field or method R is accessible to a class D (destinationClass) iff
+     *  (B1) R is public
+     *  (B2) R is protected, declared in C (memberDeclClass) and D is a subclass of C.
+     *       If R is not static, R must contain a symbolic reference to a class T (memberRefClass),
+     *       such that T is either a subclass of D, a superclass of D, or D itself.
+     *  (B3) R is either protected or has default access and declared by a class in the same
+     *       run-time package as D.
+     *  (B4) R is private and is declared in D.
+     */
+    def memberIsAccessible(memberFlags: Int, memberDeclClass: ClassBType, memberRefClass: ClassBType): Either[OptimizerWarning, Boolean] = {
+      // TODO: B3 requires "same run-time package", which seems to be package + classloader (JMVS 5.3.). is the below ok?
+      def samePackageAsDestination = memberDeclClass.packageInternalName == destinationClass.packageInternalName
+
+      val key = (ACC_PUBLIC | ACC_PROTECTED | ACC_PRIVATE) & memberFlags
+      key match {
+        case ACC_PUBLIC     =>       // B1
+          Right(true)
+
+        case ACC_PROTECTED  =>       // B2
+          tryEither {
+            val condB2 = destinationClass.isSubtypeOf(memberDeclClass).orThrow && {
+              val isStatic = (ACC_STATIC & memberFlags) != 0
+              isStatic || memberRefClass.isSubtypeOf(destinationClass).orThrow || destinationClass.isSubtypeOf(memberRefClass).orThrow
+            }
+            Right(condB2 || samePackageAsDestination) // B3 (protected)
+          }
+
+        case 0 =>                    // B3 (default access)
+          Right(samePackageAsDestination)
+
+        case ACC_PRIVATE    =>       // B4
+          Right(memberDeclClass == destinationClass)
+      }
+    }
+
+    /**
+     * Check if `instruction` can be transplanted to `destinationClass`.
+     *
+     * If the instruction references a class, method or field that cannot be found in the
+     * byteCodeRepository, it is considered as not legal. This is known to happen in mixed
+     * compilation: for Java classes there is no classfile that could be parsed, nor does the
+     * compiler generate any bytecode.
+     *
+     * Returns a warning message describing the problem if checking the legality for the instruction
+     * failed.
+     */
+    def isLegal(instruction: AbstractInsnNode): Either[OptimizerWarning, Boolean] = instruction match {
+      case ti: TypeInsnNode  =>
+        // NEW, ANEWARRAY, CHECKCAST or INSTANCEOF. For these instructions, the reference
+        // "must be a symbolic reference to a class, array, or interface type" (JVMS 6), so
+        // it can be an internal name, or a full array descriptor.
+        classIsAccessible(bTypeForDescriptorOrInternalNameFromClassfile(ti.desc))
+
+      case ma: MultiANewArrayInsnNode =>
+        // "a symbolic reference to a class, array, or interface type"
+        classIsAccessible(bTypeForDescriptorOrInternalNameFromClassfile(ma.desc))
+
+      case fi: FieldInsnNode =>
+        val fieldRefClass = classBTypeFromParsedClassfile(fi.owner)
+        for {
+          (fieldNode, fieldDeclClassNode) <- byteCodeRepository.fieldNode(fieldRefClass.internalName, fi.name, fi.desc): Either[OptimizerWarning, (FieldNode, InternalName)]
+          fieldDeclClass                  =  classBTypeFromParsedClassfile(fieldDeclClassNode)
+          res                             <- memberIsAccessible(fieldNode.access, fieldDeclClass, fieldRefClass)
+        } yield {
+          res
+        }
+
+      case mi: MethodInsnNode =>
+        if (mi.owner.charAt(0) == '[') Right(true) // array methods are accessible
+        else {
+          def canInlineCall(opcode: Int, methodFlags: Int, methodDeclClass: ClassBType, methodRefClass: ClassBType): Either[OptimizerWarning, Boolean] = {
+            opcode match {
+              case INVOKESPECIAL if mi.name != GenBCode.INSTANCE_CONSTRUCTOR_NAME =>
+                // invokespecial is used for private method calls, super calls and instance constructor calls.
+                // private method and super calls can only be inlined into the same class.
+                Right(destinationClass == calleeDeclarationClass)
+
+              case _ => // INVOKEVIRTUAL, INVOKESTATIC, INVOKEINTERFACE and INVOKESPECIAL of constructors
+                memberIsAccessible(methodFlags, methodDeclClass, methodRefClass)
+            }
+          }
+
+          val methodRefClass = classBTypeFromParsedClassfile(mi.owner)
+          for {
+            (methodNode, methodDeclClassNode) <- byteCodeRepository.methodNode(methodRefClass.internalName, mi.name, mi.desc): Either[OptimizerWarning, (MethodNode, InternalName)]
+            methodDeclClass                   =  classBTypeFromParsedClassfile(methodDeclClassNode)
+            res                               <- canInlineCall(mi.getOpcode, methodNode.access, methodDeclClass, methodRefClass)
+          } yield {
+            res
+          }
+        }
+
+      case ivd: InvokeDynamicInsnNode =>
+        // TODO @lry check necessary conditions to inline an indy, instead of giving up
+        Right(false)
+
+      case ci: LdcInsnNode => ci.cst match {
+        case t: asm.Type => classIsAccessible(bTypeForDescriptorOrInternalNameFromClassfile(t.getInternalName))
+        case _           => Right(true)
+      }
+
+      case _ => Right(true)
+    }
+
+    val it = instructions.iterator.asScala
+    @tailrec def find: Option[(AbstractInsnNode, Option[OptimizerWarning])] = {
+      if (!it.hasNext) None // all instructions are legal
+      else {
+        val i = it.next()
+        isLegal(i) match {
+          case Left(warning) => Some((i, Some(warning))) // checking isLegal for i failed
+          case Right(false)  => Some((i, None))          // an illegal instruction was found
+          case _             => find
+        }
+      }
+    }
+    find
+  }
+}
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/opt/LocalOpt.scala b/src/compiler/scala/tools/nsc/backend/jvm/opt/LocalOpt.scala
index 87ad715e4d..f6cfc5598b 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/opt/LocalOpt.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/opt/LocalOpt.scala
@@ -8,10 +8,11 @@ package backend.jvm
 package opt
 
 import scala.annotation.switch
-import scala.tools.asm.{Opcodes, MethodWriter, ClassWriter}
-import scala.tools.asm.tree.analysis.{Analyzer, BasicValue, BasicInterpreter}
+import scala.tools.asm.Opcodes
+import scala.tools.asm.tree.analysis.{Analyzer, BasicInterpreter}
 import scala.tools.asm.tree._
 import scala.collection.convert.decorateAsScala._
+import scala.tools.nsc.backend.jvm.BTypes.InternalName
 import scala.tools.nsc.backend.jvm.opt.BytecodeUtils._
 import scala.tools.nsc.settings.ScalaSettings
 
@@ -48,6 +49,45 @@ import scala.tools.nsc.settings.ScalaSettings
  */
 class LocalOpt(settings: ScalaSettings) {
   /**
+   * Remove unreachable code from all methods of `classNode`. See of its overload.
+   *
+   * @param classNode The class to optimize
+   * @return          `true` if unreachable code was removed from any method
+   */
+  def minimalRemoveUnreachableCode(classNode: ClassNode): Boolean = {
+    classNode.methods.asScala.foldLeft(false) {
+      case (changed, method) => minimalRemoveUnreachableCode(method, classNode.name) || changed
+    }
+  }
+
+  /**
+   * Remove unreachable code from a method.
+   *
+   * This implementation only removes instructions that are unreachable for an ASM analyzer /
+   * interpreter. This ensures that future analyses will not produce `null` frames. The inliner
+   * and call graph builder depend on this property.
+   */
+  def minimalRemoveUnreachableCode(method: MethodNode, ownerClassName: InternalName): Boolean = {
+    if (method.instructions.size == 0) return false // fast path for abstract methods
+
+    // For correctness, after removing unreachable code, we have to eliminate empty exception
+    // handlers, see scaladoc of def methodOptimizations. Removing an live handler may render more
+    // code unreachable and therefore requires running another round.
+    def removalRound(): Boolean = {
+      val (codeRemoved, liveLabels) = removeUnreachableCodeImpl(method, ownerClassName)
+      if (codeRemoved) {
+        val liveHandlerRemoved = removeEmptyExceptionHandlers(method).exists(h => liveLabels(h.start))
+        if (liveHandlerRemoved) removalRound()
+      }
+      codeRemoved
+    }
+
+    val codeRemoved = removalRound()
+    if (codeRemoved) removeUnusedLocalVariableNodes(method)()
+    codeRemoved
+  }
+
+  /**
    * Remove unreachable instructions from all (non-abstract) methods and apply various other
    * cleanups to the bytecode.
    *
@@ -73,7 +113,7 @@ class LocalOpt(settings: ScalaSettings) {
    *
    * Returns `true` if the bytecode of `method` was changed.
    */
-  private def methodOptimizations(method: MethodNode, ownerClassName: String): Boolean = {
+  def methodOptimizations(method: MethodNode, ownerClassName: InternalName): Boolean = {
     if (method.instructions.size == 0) return false // fast path for abstract methods
 
     // unreachable-code also removes unused local variable nodes and empty exception handlers.
@@ -102,9 +142,7 @@ class LocalOpt(settings: ScalaSettings) {
     // This triggers "ClassFormatError: Illegal exception table range in class file C". Similar
     // for local variables in dead blocks. Maybe that's a bug in the ASM framework.
 
-    var recurse = true
-    var codeHandlersOrJumpsChanged = false
-    while (recurse) {
+    def removalRound(): Boolean = {
       // unreachable-code, empty-handlers and simplify-jumps run until reaching a fixpoint (see doc on class LocalOpt)
       val (codeRemoved, handlersRemoved, liveHandlerRemoved) = if (settings.YoptUnreachableCode) {
         val (codeRemoved, liveLabels) = removeUnreachableCodeImpl(method, ownerClassName)
@@ -116,15 +154,18 @@ class LocalOpt(settings: ScalaSettings) {
 
       val jumpsChanged = if (settings.YoptSimplifyJumps) simplifyJumps(method) else false
 
-      codeHandlersOrJumpsChanged ||= (codeRemoved || handlersRemoved || jumpsChanged)
+      // Eliminating live handlers and simplifying jump instructions may render more code
+      // unreachable, so we need to run another round.
+      if (liveHandlerRemoved || jumpsChanged) removalRound()
 
-      // The doc comment of class LocalOpt explains why we recurse if jumpsChanged || liveHandlerRemoved
-      recurse = settings.YoptRecurseUnreachableJumps && (jumpsChanged || liveHandlerRemoved)
+      codeRemoved || handlersRemoved || jumpsChanged
     }
 
+    val codeHandlersOrJumpsChanged = removalRound()
+
     // (*) Removing stale local variable descriptors is required for correctness of unreachable-code
     val localsRemoved =
-      if (settings.YoptCompactLocals) compactLocalVariables(method)
+      if (settings.YoptCompactLocals) compactLocalVariables(method) // also removes unused
       else if (settings.YoptUnreachableCode) removeUnusedLocalVariableNodes(method)() // (*)
       else false
 
@@ -146,10 +187,10 @@ class LocalOpt(settings: ScalaSettings) {
    *
    * TODO: rewrite, don't use computeMaxLocalsMaxStack (runs a ClassWriter) / Analyzer. Too slow.
    */
-  def removeUnreachableCodeImpl(method: MethodNode, ownerClassName: String): (Boolean, Set[LabelNode]) = {
+  def removeUnreachableCodeImpl(method: MethodNode, ownerClassName: InternalName): (Boolean, Set[LabelNode]) = {
     // The data flow analysis requires the maxLocals / maxStack fields of the method to be computed.
     computeMaxLocalsMaxStack(method)
-    val a = new Analyzer[BasicValue](new BasicInterpreter)
+    val a = new Analyzer(new BasicInterpreter)
     a.analyze(ownerClassName, method)
     val frames = a.getFrames
 
@@ -319,29 +360,6 @@ class LocalOpt(settings: ScalaSettings) {
   }
 
   /**
-   * In order to run an Analyzer, the maxLocals / maxStack fields need to be available. The ASM
-   * framework only computes these values during bytecode generation.
-   *
-   * Since there's currently no better way, we run a bytecode generator on the method and extract
-   * the computed values. This required changes to the ASM codebase:
-   *   - the [[MethodWriter]] class was made public
-   *   - accessors for maxLocals / maxStack were added to the MethodWriter class
-   *
-   * We could probably make this faster (and allocate less memory) by hacking the ASM framework
-   * more: create a subclass of MethodWriter with a /dev/null byteVector. Another option would be
-   * to create a separate visitor for computing those values, duplicating the functionality from the
-   * MethodWriter.
-   */
-  private def computeMaxLocalsMaxStack(method: MethodNode) {
-    val cw = new ClassWriter(ClassWriter.COMPUTE_MAXS)
-    val excs = method.exceptions.asScala.toArray
-    val mw = cw.visitMethod(method.access, method.name, method.desc, method.signature, excs).asInstanceOf[MethodWriter]
-    method.accept(mw)
-    method.maxLocals = mw.getMaxLocals
-    method.maxStack = mw.getMaxStack
-  }
-
-  /**
    * Removes LineNumberNodes that don't describe any executable instructions.
    *
    * This method expects (and asserts) that the `start` label of each LineNumberNode is the
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/opt/OptimizerReporting.scala b/src/compiler/scala/tools/nsc/backend/jvm/opt/OptimizerReporting.scala
deleted file mode 100644
index 7002e43d98..0000000000
--- a/src/compiler/scala/tools/nsc/backend/jvm/opt/OptimizerReporting.scala
+++ /dev/null
@@ -1,24 +0,0 @@
-/* NSC -- new Scala compiler
- * Copyright 2005-2014 LAMP/EPFL
- * @author  Martin Odersky
- */
-
-package scala.tools.nsc
-package backend.jvm
-
-import scala.tools.asm
-import asm.tree._
-
-/**
- * Reporting utilities used in the optimizer.
- */
-object OptimizerReporting {
-  def methodSignature(className: String, methodName: String, methodDescriptor: String): String = {
-    className + "::" + methodName + methodDescriptor
-  }
-
-  def methodSignature(className: String, method: MethodNode): String = methodSignature(className, method.name, method.desc)
-
-  def inlineFailure(reason: String): Nothing = MissingRequirementError.signal(reason)
-  def assertionError(message: String): Nothing = throw new AssertionError(message)
-}
diff --git a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala
index d7f4cca615..d273995e6e 100644
--- a/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala
+++ b/src/compiler/scala/tools/nsc/settings/ScalaSettings.scala
@@ -218,23 +218,24 @@ trait ScalaSettings extends AbsScalaSettings
   object YoptChoices extends MultiChoiceEnumeration {
     val unreachableCode         = Choice("unreachable-code",          "Eliminate unreachable code, exception handlers protecting no instructions, debug information of eliminated variables.")
     val simplifyJumps           = Choice("simplify-jumps",            "Simplify branching instructions, eliminate unnecessary ones.")
-    val recurseUnreachableJumps = Choice("recurse-unreachable-jumps", "Recursively apply unreachable-code and simplify-jumps (if enabled) until reaching a fixpoint.")
     val emptyLineNumbers        = Choice("empty-line-numbers",        "Eliminate unnecessary line number information.")
     val emptyLabels             = Choice("empty-labels",              "Eliminate and collapse redundant labels in the bytecode.")
     val compactLocals           = Choice("compact-locals",            "Eliminate empty slots in the sequence of local variables.")
+    val inlineProject           = Choice("inline-project",            "Inline only methods defined in the files being compiled")
+    val inlineGlobal            = Choice("inline-global",             "Inline methods from any source, including classfiles on the compile classpath")
 
     val lNone           = Choice("l:none",      "Don't enable any optimizations.")
 
     private val defaultChoices = List(unreachableCode)
     val lDefault        = Choice("l:default",   "Enable default optimizations: "+ defaultChoices.mkString(","),                                    expandsTo = defaultChoices)
 
-    private val methodChoices = List(unreachableCode, simplifyJumps, recurseUnreachableJumps, emptyLineNumbers, emptyLabels, compactLocals)
+    private val methodChoices = List(unreachableCode, simplifyJumps, emptyLineNumbers, emptyLabels, compactLocals)
     val lMethod         = Choice("l:method",    "Enable intra-method optimizations: "+ methodChoices.mkString(","),                                expandsTo = methodChoices)
 
-    private val projectChoices = List(lMethod)
+    private val projectChoices = List(lMethod, inlineProject)
     val lProject        = Choice("l:project",   "Enable cross-method optimizations within the current project: "+ projectChoices.mkString(","),    expandsTo = projectChoices)
 
-    private val classpathChoices = List(lProject)
+    private val classpathChoices = List(lProject, inlineGlobal)
     val lClasspath      = Choice("l:classpath", "Enable cross-method optimizations across the entire classpath: "+ classpathChoices.mkString(","), expandsTo = classpathChoices)
   }
 
@@ -247,11 +248,33 @@ trait ScalaSettings extends AbsScalaSettings
   def YoptNone                    = Yopt.isSetByUser && Yopt.value.isEmpty
   def YoptUnreachableCode         = !Yopt.isSetByUser || Yopt.contains(YoptChoices.unreachableCode)
   def YoptSimplifyJumps           = Yopt.contains(YoptChoices.simplifyJumps)
-  def YoptRecurseUnreachableJumps = Yopt.contains(YoptChoices.recurseUnreachableJumps)
   def YoptEmptyLineNumbers        = Yopt.contains(YoptChoices.emptyLineNumbers)
   def YoptEmptyLabels             = Yopt.contains(YoptChoices.emptyLabels)
   def YoptCompactLocals           = Yopt.contains(YoptChoices.compactLocals)
 
+  def YoptInlineProject           = Yopt.contains(YoptChoices.inlineProject)
+  def YoptInlineGlobal            = Yopt.contains(YoptChoices.inlineGlobal)
+  def YoptInlinerEnabled          = YoptInlineProject || YoptInlineGlobal
+
+  object YoptWarningsChoices extends MultiChoiceEnumeration {
+    val none                               = Choice("none"                       , "No optimizer warnings.")
+    val atInlineFailedSummary              = Choice("at-inline-failed-summary"   , "One-line summary if there were @inline method calls that could not be inlined.")
+    val atInlineFailed                     = Choice("at-inline-failed"           , "A detailed warning for each @inline method call that could not be inlined.")
+    val noInlineMixed                      = Choice("no-inline-mixed"            , "In mixed compilation, warn at callsites methods defined in java sources (the inlining decision cannot be made without bytecode).")
+    val noInlineMissingBytecode            = Choice("no-inline-missing-bytecode" , "Warn if an inlining decision cannot be made because a the bytecode of a class or member cannot be found on the compilation classpath.")
+    val noInlineMissingScalaInlineInfoAttr = Choice("no-inline-missing-attribute", "Warn if an inlining decision cannot be made because a Scala classfile does not have a ScalaInlineInfo attribute.")
+  }
+
+  val YoptWarnings = MultiChoiceSetting(
+    name = "-Yopt-warnings",
+    helpArg = "warnings",
+    descr = "Enable optimizer warnings",
+    domain = YoptWarningsChoices,
+    default = Some(List(YoptWarningsChoices.atInlineFailed.name))) withPostSetHook (self => {
+    if (self.value subsetOf Set(YoptWarningsChoices.none, YoptWarningsChoices.atInlineFailedSummary)) YinlinerWarnings.value = false
+    else YinlinerWarnings.value = true
+  })
+
   private def removalIn212 = "This flag is scheduled for removal in 2.12. If you have a case where you need this flag then please report a bug."
 
   object YstatisticsPhases extends MultiChoiceEnumeration { val parser, typer, patmat, erasure, cleanup, jvm = Value }
diff --git a/src/compiler/scala/tools/nsc/transform/Delambdafy.scala b/src/compiler/scala/tools/nsc/transform/Delambdafy.scala
index 1f832ba81e..94e88589f5 100644
--- a/src/compiler/scala/tools/nsc/transform/Delambdafy.scala
+++ b/src/compiler/scala/tools/nsc/transform/Delambdafy.scala
@@ -255,6 +255,8 @@ abstract class Delambdafy extends Transform with TypingTransformers with ast.Tre
         val name = unit.freshTypeName(s"$oldClassPart$suffix".replace("$anon", "$nestedInAnon"))
 
         val lambdaClass = pkg newClassSymbol(name, originalFunction.pos, FINAL | SYNTHETIC) addAnnotation SerialVersionUIDAnnotation
+        // make sure currentRun.compiles(lambdaClass) is true (AddInterfaces does the same for trait impl classes)
+        currentRun.symSource(lambdaClass) = funOwner.sourceFile
         lambdaClass setInfo ClassInfoType(parents, newScope, lambdaClass)
         assert(!lambdaClass.isAnonymousClass && !lambdaClass.isAnonymousFunction, "anonymous class name: "+ lambdaClass.name)
         assert(lambdaClass.isDelambdafyFunction, "not lambda class name: " + lambdaClass.name)
diff --git a/src/reflect/scala/reflect/internal/SymbolTable.scala b/src/reflect/scala/reflect/internal/SymbolTable.scala
index 01e4cdf367..ef63078f90 100644
--- a/src/reflect/scala/reflect/internal/SymbolTable.scala
+++ b/src/reflect/scala/reflect/internal/SymbolTable.scala
@@ -355,6 +355,14 @@ abstract class SymbolTable extends macros.Universe
       cache
     }
 
+    /**
+     * Removes a cache from the per-run caches. This is useful for testing: it allows running the
+     * compiler and then inspect the state of a cache.
+     */
+    def unrecordCache[T <: Clearable](cache: T): Unit = {
+      caches = caches.filterNot(_.get eq cache)
+    }
+
     def clearAll() = {
       debuglog("Clearing " + caches.size + " caches.")
       caches foreach (ref => Option(ref.get).foreach(_.clear))