WIP remove dead code in the optimizer

retronym · retronym · commit 772531210066 · 2016-02-25T14:27:07.000+10:00
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala b/src/compiler/scala/tools/nsc/backend/jvm/BCodeHelpers.scala
@@ -295,7 +295,6 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
 
           val info = MethodInlineInfo(
             effectivelyFinal                    = effectivelyFinal,
-            traitMethodWithStaticImplementation = false,
             annotatedInline                     = methodSym.hasAnnotation(ScalaInlineClass),
             annotatedNoInline                   = methodSym.hasAnnotation(ScalaNoInlineClass)
           )
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala b/src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala
@@ -255,13 +255,11 @@ abstract class BTypes {
       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),
         sam = inlinerHeuristics.javaSam(classNode.name),
         methodInfos = methodInfos,
@@ -1139,22 +1137,8 @@ object BTypes {
    * Note that this class should contain information that can only be obtained from the ClassSymbol.
    * Information that can be computed from the ClassNode should be added to the call graph instead.
    *
-   * @param traitImplClassSelfType `Some(tp)` if this InlineInfo describes a trait, and the `self`
-   *                               parameter type of the methods in the implementation class is not
-   *                               the trait itself. Example:
-   *                                 trait T { self: U => def f = 1 }
-   *                               Generates something like:
-   *                                 class T$class { static def f(self: U) = 1 }
-   *
-   *                               In order to inline a trat method call, the INVOKEINTERFACE is
-   *                               rewritten to an INVOKESTATIC of the impl class, so we need the
-   *                               self type (U) to get the right signature.
-   *
-   *                               `None` if the self type is the interface type, or if this
-   *                               InlineInfo does not describe a trait.
-   *
    * @param isEffectivelyFinal     True if the class cannot have subclasses: final classes, module
-   *                               classes, trait impl classes.
+   *                               classes.
    *
    * @param sam                    If this class is a SAM type, the SAM's "$name$descriptor".
    *
@@ -1166,26 +1150,21 @@ object BTypes {
    *                               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,
+  final case class InlineInfo(isEffectivelyFinal: Boolean,
                               sam: Option[String],
                               methodInfos: Map[String, MethodInlineInfo],
                               warning: Option[ClassInlineInfoWarning])
 
-  val EmptyInlineInfo = InlineInfo(None, false, None, Map.empty, None)
+  val EmptyInlineInfo = InlineInfo(false, None, Map.empty, None)
 
   /**
    * Metadata about a method, used by the inliner.
    *
    * @param effectivelyFinal                    True if the method cannot be overridden (in Scala)
-   * @param traitMethodWithStaticImplementation True if the method is an interface method method of
-   *                                            a trait method and has a static counterpart in the
-   *                                            implementation class.
    * @param annotatedInline                     True if the method is annotated `@inline`
    * @param annotatedNoInline                   True if the method is annotated `@noinline`
    */
   final case class MethodInlineInfo(effectivelyFinal: Boolean,
-                                    traitMethodWithStaticImplementation: Boolean,
                                     annotatedInline: Boolean,
                                     annotatedNoInline: Boolean)
 
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/opt/CallGraph.scala b/src/compiler/scala/tools/nsc/backend/jvm/opt/CallGraph.scala
@@ -132,17 +132,9 @@ class CallGraph[BT <: BTypes](val btypes: BT) {
               (declarationClassNode, source) <- byteCodeRepository.classNodeAndSource(declarationClass): Either[OptimizerWarning, (ClassNode, Source)]
             } yield {
                 val declarationClassBType = classBTypeFromClassNode(declarationClassNode)
-                val CallsiteInfo(safeToInline, safeToRewrite, canInlineFromSource, annotatedInline, annotatedNoInline, samParamTypes, warning) = analyzeCallsite(method, declarationClassBType, call.owner, source)
-                Callee(
-                  callee = method,
-                  calleeDeclarationClass = declarationClassBType,
-                  safeToInline = safeToInline,
-                  safeToRewrite = false,
-                  canInlineFromSource = canInlineFromSource,
-                  annotatedInline = annotatedInline,
-                  annotatedNoInline = annotatedNoInline,
-                  samParamTypes = samParamTypes,
-                  calleeInfoWarning = warning)
+                val info = analyzeCallsite(method, declarationClassBType, call.owner, source)
+                import info._
+                Callee(callee = method, calleeDeclarationClass = declarationClassBType, safeToInline = safeToInline, canInlineFromSource = canInlineFromSource, annotatedInline = annotatedInline, annotatedNoInline = annotatedNoInline, samParamTypes = samParamTypes, calleeInfoWarning = warning)
               }
 
             val argInfos = computeArgInfos(callee, call, prodCons)
@@ -256,7 +248,7 @@ class CallGraph[BT <: BTypes](val btypes: BT) {
   /**
    * Just a named tuple used as return type of `analyzeCallsite`.
    */
-  private case class CallsiteInfo(safeToInline: Boolean, safeToRewrite: Boolean, canInlineFromSource: Boolean,
+  private case class CallsiteInfo(safeToInline: Boolean, canInlineFromSource: Boolean,
                                   annotatedInline: Boolean, annotatedNoInline: Boolean,
                                   samParamTypes: IntMap[ClassBType],
                                   warning: Option[CalleeInfoWarning])
@@ -299,16 +291,12 @@ class CallGraph[BT <: BTypes](val btypes: BT) {
               receiverType.info.orThrow.inlineInfo.isEffectivelyFinal // (1)
           }
 
-          val isRewritableTraitCall = false
-
           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 &&
@@ -317,7 +305,6 @@ class CallGraph[BT <: BTypes](val btypes: BT) {
                 !BytecodeUtils.isConstructor(calleeMethodNode) &&
                 !BytecodeUtils.isNativeMethod(calleeMethodNode) &&
                 !BytecodeUtils.hasCallerSensitiveAnnotation(calleeMethodNode),
-            safeToRewrite       = canInlineFromSource && isRewritableTraitCall, // (2)
             canInlineFromSource = canInlineFromSource,
             annotatedInline     = methodInlineInfo.annotatedInline,
             annotatedNoInline   = methodInlineInfo.annotatedNoInline,
@@ -326,12 +313,12 @@ class CallGraph[BT <: BTypes](val btypes: BT) {
 
         case None =>
           val warning = MethodInlineInfoMissing(calleeDeclarationClassBType.internalName, calleeMethodNode.name, calleeMethodNode.desc, calleeDeclarationClassBType.info.orThrow.inlineInfo.warning)
-          CallsiteInfo(false, false, false, false, false, IntMap.empty, Some(warning))
+          CallsiteInfo(false, false, false, false, IntMap.empty, Some(warning))
       }
     } catch {
       case Invalid(noInfo: NoClassBTypeInfo) =>
         val warning = MethodInlineInfoError(calleeDeclarationClassBType.internalName, calleeMethodNode.name, calleeMethodNode.desc, noInfo)
-        CallsiteInfo(false, false, false, false, false, IntMap.empty, Some(warning))
+        CallsiteInfo(false, false, false, false, IntMap.empty, Some(warning))
     }
   }
 
@@ -386,20 +373,13 @@ class CallGraph[BT <: BTypes](val btypes: BT) {
    * @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 is 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 samParamTypes          A map from parameter positions to SAM parameter types
    * @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, canInlineFromSource: Boolean,
-                          annotatedInline: Boolean, annotatedNoInline: Boolean,
-                          samParamTypes: IntMap[ClassBType],
-                          calleeInfoWarning: Option[CalleeInfoWarning]) {
-    assert(!(safeToInline && safeToRewrite), s"A callee of ${callee.name} can be either safeToInline or safeToRewrite, but not both.")
+  final case class Callee(callee: MethodNode, calleeDeclarationClass: btypes.ClassBType, safeToInline: Boolean, canInlineFromSource: Boolean, annotatedInline: Boolean, annotatedNoInline: Boolean, samParamTypes: IntMap[btypes.ClassBType], calleeInfoWarning: Option[CalleeInfoWarning]) {
     override def toString = s"Callee($calleeDeclarationClass.${callee.name})"
   }
 
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/opt/ClosureOptimizer.scala b/src/compiler/scala/tools/nsc/backend/jvm/opt/ClosureOptimizer.scala
@@ -359,16 +359,7 @@ class ClosureOptimizer[BT <: BTypes](val btypes: BT) {
       case (bodyMethodNode, bodyMethodDeclClass) =>
         val bodyDeclClassType = classBTypeFromParsedClassfile(bodyMethodDeclClass)
         val canInlineFromSource = compilerSettings.YoptInlineGlobal || bodyMethodIsBeingCompiled
-        Callee(
-          callee = bodyMethodNode,
-          calleeDeclarationClass = bodyDeclClassType,
-          safeToInline = canInlineFromSource,
-          safeToRewrite = false, // the lambda body method is not a trait interface method
-          canInlineFromSource = canInlineFromSource,
-          annotatedInline = false,
-          annotatedNoInline = false,
-          samParamTypes = callGraph.samParamTypes(bodyMethodNode, bodyDeclClassType),
-          calleeInfoWarning = None)
+        Callee(callee = bodyMethodNode, calleeDeclarationClass = bodyDeclClassType, safeToInline = canInlineFromSource, canInlineFromSource = canInlineFromSource, annotatedInline = false, annotatedNoInline = false, samParamTypes = callGraph.samParamTypes(bodyMethodNode, bodyDeclClassType), calleeInfoWarning = None)
     })
     val argInfos = closureInit.capturedArgInfos ++ originalCallsite.map(cs => cs.argInfos map {
       case (index, info) => (index + numCapturedValues, info)
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/opt/InlineInfoAttribute.scala b/src/compiler/scala/tools/nsc/backend/jvm/opt/InlineInfoAttribute.scala
@@ -27,7 +27,7 @@ import scala.tools.nsc.backend.jvm.BackendReporting.UnknownScalaInlineInfoVersio
  * In principle we could encode the InlineInfo into a Java annotation (instead of a classfile attribute).
  * However, an attribute allows us to save many bits. In particular, note that the strings in an
  * InlineInfo are serialized as references to constants in the constant pool, and those strings
- * (traitImplClassSelfType, method names, method signatures) would exist in there anyway. So the
+ * (method names, method signatures) would exist in there anyway. So the
  * ScalaInlineAttribute remains relatively compact.
  */
 case class InlineInfoAttribute(inlineInfo: InlineInfo) extends Attribute(InlineInfoAttribute.attributeName) {
@@ -49,14 +49,9 @@ case class InlineInfoAttribute(inlineInfo: InlineInfo) extends Attribute(InlineI
 
     var finalSelfSam = 0
     if (inlineInfo.isEffectivelyFinal)               finalSelfSam |= 1
-    if (inlineInfo.traitImplClassSelfType.isDefined) finalSelfSam |= 2
-    if (inlineInfo.sam.isDefined)                    finalSelfSam |= 4
+    if (inlineInfo.sam.isDefined)                    finalSelfSam |= 2
     result.putByte(finalSelfSam)
 
-    for (selfInternalName <- inlineInfo.traitImplClassSelfType) {
-      result.putShort(cw.newUTF8(selfInternalName))
-    }
-
     for (samNameDesc <- inlineInfo.sam) {
       val (name, desc) = samNameDesc.span(_ != '(')
       result.putShort(cw.newUTF8(name))
@@ -76,9 +71,8 @@ case class InlineInfoAttribute(inlineInfo: InlineInfo) extends Attribute(InlineI
 
       var inlineInfo = 0
       if (info.effectivelyFinal)                    inlineInfo |= 1
-      if (info.traitMethodWithStaticImplementation) inlineInfo |= 2
-      if (info.annotatedInline)                     inlineInfo |= 4
-      if (info.annotatedNoInline)                   inlineInfo |= 8
+      if (info.annotatedInline)                     inlineInfo |= 2
+      if (info.annotatedNoInline)                   inlineInfo |= 4
       result.putByte(inlineInfo)
     }
 
@@ -103,7 +97,7 @@ case class InlineInfoAttribute(inlineInfo: InlineInfo) extends Attribute(InlineI
     if (version == 1) {
       val finalSelfSam = nextByte()
       val isFinal = (finalSelfSam & 1) != 0
-      val hasSelf = (finalSelfSam & 2) != 0
+      val hasSelf = (finalSelfSam & 2) != 0  // no longer used
       val hasSam  = (finalSelfSam & 4) != 0
 
       val self = if (!hasSelf) None else {
@@ -124,13 +118,37 @@ case class InlineInfoAttribute(inlineInfo: InlineInfo) extends Attribute(InlineI
 
         val inlineInfo = nextByte()
         val isFinal                             = (inlineInfo & 1) != 0
-        val traitMethodWithStaticImplementation = (inlineInfo & 2) != 0
+        val traitMethodWithStaticImplementation = (inlineInfo & 2) != 0 // no longer used
         val isInline                            = (inlineInfo & 4) != 0
         val isNoInline                          = (inlineInfo & 8) != 0
-        (name + desc, MethodInlineInfo(isFinal, traitMethodWithStaticImplementation, isInline, isNoInline))
+        (name + desc, MethodInlineInfo(isFinal, isInline, isNoInline))
+      }).toMap
+
+      InlineInfoAttribute(InlineInfo(isFinal, sam, infos, None))
+    } else if (version == 2) {
+      val finalSelfSam = nextByte()
+      val isFinal = (finalSelfSam & 1) != 0
+      val hasSam  = (finalSelfSam & 2) != 0
+
+      val sam = if (!hasSam) None else {
+        val name = nextUTF8()
+        val desc = nextUTF8()
+        Some(name + desc)
+      }
+
+      val numEntries = nextShort()
+      val infos = (0 until numEntries).map(_ => {
+        val name = nextUTF8()
+        val desc = nextUTF8()
+
+        val inlineInfo = nextByte()
+        val isFinal                             = (inlineInfo & 1) != 0
+        val isInline                            = (inlineInfo & 2) != 0
+        val isNoInline                          = (inlineInfo & 4) != 0
+        (name + desc, MethodInlineInfo(isFinal, isInline, isNoInline))
       }).toMap
 
-      InlineInfoAttribute(InlineInfo(self, isFinal, sam, infos, None))
+      InlineInfoAttribute(InlineInfo(isFinal, sam, infos, None))
     } else {
       val msg = UnknownScalaInlineInfoVersion(cr.getClassName, version)
       InlineInfoAttribute(BTypes.EmptyInlineInfo.copy(warning = Some(msg)))
@@ -141,16 +159,15 @@ case class InlineInfoAttribute(inlineInfo: InlineInfo) extends Attribute(InlineI
 object InlineInfoAttribute {
   /**
    * [u1]    version
-   * [u1]    isEffectivelyFinal (<< 0), hasTraitImplClassSelfType (<< 1), hasSam (<< 2)
-   * [u2]?   traitImplClassSelfType (reference)
+   * [u1]    isEffectivelyFinal (<< 0), hasSam (<< 1)
    * [u2]?   samName (reference)
    * [u2]?   samDescriptor (reference)
    * [u2]    numMethodEntries
    *   [u2]  name (reference)
    *   [u2]  descriptor (reference)
-   *   [u1]  isFinal (<< 0), traitMethodWithStaticImplementation (<< 1), hasInlineAnnotation (<< 2), hasNoInlineAnnotation (<< 3)
+   *   [u1]  isFinal (<< 0), hasInlineAnnotation (<< 2), hasNoInlineAnnotation (<< 3)
    */
-  final val VERSION: Byte = 1
+  final val VERSION: Byte = 2
 
   final val attributeName = "ScalaInlineInfo"
 }
@@ -159,4 +176,4 @@ object InlineInfoAttribute {
  * In order to instruct the ASM framework to de-serialize the ScalaInlineInfo attribute, we need
  * to pass a prototype instance when running the class reader.
  */
-object InlineInfoAttributePrototype extends InlineInfoAttribute(InlineInfo(null, false, null, null, null))
+object InlineInfoAttributePrototype extends InlineInfoAttribute(InlineInfo(false, null, null, null))
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/opt/Inliner.scala b/src/compiler/scala/tools/nsc/backend/jvm/opt/Inliner.scala
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/opt/InlinerHeuristics.scala b/src/compiler/scala/tools/nsc/backend/jvm/opt/InlinerHeuristics.scala

Original file line number	Diff line number	Diff line change
`@@ -295,7 +295,6 @@ abstract class BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {`
`295`	`295`
`296`	`296`	`val info = MethodInlineInfo(`
`297`	`297`	`effectivelyFinal = effectivelyFinal,`
`298`		`- traitMethodWithStaticImplementation = false,`
`299`	`298`	`annotatedInline = methodSym.hasAnnotation(ScalaInlineClass),`
`300`	`299`	`annotatedNoInline = methodSym.hasAnnotation(ScalaNoInlineClass)`
`301`	`300`	`)`