detecting what are to become "really static" classes

This commit tracks "really static" module classes. A follow-up commit will add support for "statification" proper (a transformation performed on-the-fly by GenBCode for "really static" module classes and their usage sites).

A "really static" module-class fulfills four conditions:
  (0) marked @reallyStatic
  (1) the module-class is a static module
  (2) the module-class is direct subclass of AnyRef
  (3) the module-class extends either no interfaces or just marker interfaces

Author: magarciaEPFL

src/compiler/scala/tools/nsc/backend/jvm/BCodeTypes.scala

@@ -25,6 +25,46 @@ abstract class BCodeTypes extends SubComponent with BytecodeWriters {
 
   val isLateClosuresOn = (settings.isClosureConvDelegating || settings.isClosureConvMH)
 
+  def isCustomValueClass(csym: Symbol): Boolean = enteringErasure(csym.isDerivedValueClass)
+
+  /*
+   * The set `knownModClassStatification` contains
+   * those module-classes of static-modules as well as those module-classes of custom-value-classes
+   * that fulfill the conditions for `statification` checked by `isStatifiableModuleClass()`
+   *
+   * The module-class of a custom-value-class may have a side-effecting class-initializer, as the following examples show.
+   *
+   * Example 1:
+   *     class A { println("A") }
+   *     object B extends A { }
+   *     class B(val underlying: Int) extends AnyVal { }
+   *
+   * Example 2:
+   *     object C {
+   *       val singleton1 = ...
+   *     }
+   *     class C(val underlying: Int) extends AnyVal { }
+   *
+   */
+  val knownModClassStatification = mutable.Set.empty[BType]
+
+  /*
+   * "Statification" is a GenBCode-level transform that turns into static the members of those module classes
+   * that fulfill the conditions checked in `isStatifiableModuleClass()` EXCEPT those members overriding methods in the Object API.
+   * Usage sites are also adapted.
+   */
+  def shouldStatifyClass(bt: BType): Boolean = { knownModClassStatification(bt) }
+
+  def shouldStatifyClass(csym: Symbol): Boolean = {
+    shouldStatifyClass(exemplar(csym).c)
+  }
+
+  def shouldStatifyMethod(msym: Symbol, owner: BType, methodName: String): Boolean = {
+    (methodName != nme.CONSTRUCTOR.toString) &&
+    shouldStatifyClass(owner) &&
+    (msym.overriddenSymbol(definitions.ObjectClass) == NoSymbol)
+  }
+
   object BT {
 
     import global.chrs
@@ -963,6 +1003,7 @@ abstract class BCodeTypes extends SubComponent with BytecodeWriters {
   def clearBCodeTypes() {
     symExemplars.clear()
     exemplars.clear()
+    knownModClassStatification.clear()
     clearBCodeOpt()
   }
 
@@ -1291,15 +1332,20 @@ abstract class BCodeTypes extends SubComponent with BytecodeWriters {
 
   /*
    * must-single-thread
+   *
+   * @param csym denotes either a "plain class" or a "module class", see `exemplar()`
+   * @param key  the BType for csym's javaBinaryName
    */
   private def buildExemplar(key: BType, csym: Symbol): Tracked = {
+    val isImplClass = csym.isImplClass
     val sc =
-     if(csym.isImplClass) definitions.ObjectClass
+     if(isImplClass) definitions.ObjectClass
      else csym.superClass
+    val isInterface = csym.isInterface
     assert(
       if(csym == definitions.ObjectClass)
         sc == NoSymbol
-      else if(csym.isInterface)
+      else if(isInterface)
         sc == definitions.ObjectClass
       else
         ((sc != NoSymbol) && !sc.isInterface) || isCompilingStdLib,
@@ -1323,9 +1369,104 @@ abstract class BCodeTypes extends SubComponent with BytecodeWriters {
 
     val innersChain = saveInnerClassesFor(csym, key)
 
+    if(!isImplClass && !isInterface) {
+      // collect info needed later about custom value classes
+      if(csym.isModuleClass) {
+        trackModuleClass(csym, key)
+      } else if(isCustomValueClass(csym)) {
+        val mcBT = brefType(key.getInternalName + "$")
+        val modCSym = enteringErasure{ csym.linkedClassOfClass }
+        trackCustomValueClass(csym, modCSym, mcBT)
+        // notice we're not adding exemplar for the module-class --- someone else will do that
+      }
+    }
+
     Tracked(key, flags, tsc, ifacesArr, innersChain)
   }
 
+  /*
+   * Track the module class of a custom value class that fulfills the criteria for "statification".
+   */
+  private def trackCustomValueClass(plainClass: Symbol, modClass: Symbol, modClassBT: BType) {
+
+    assert(modClass != NoSymbol)
+
+    if(knownModClassStatification(modClassBT)) { return }
+
+    val isAnnotated = (modClass hasAnnotation definitions.ReallyStaticClass) || (
+      (plainClass != NoSymbol) && (plainClass hasAnnotation definitions.ReallyStaticClass)
+    )
+
+    if(!isAnnotated || !isStatifiableModuleClass(modClass)) { return }
+    knownModClassStatification += modClassBT
+
+    // // collect syms of extension methods
+    // val extMSyms = enteringErasure {
+    //   plainClass.info.members.collect{ case m if m.isMethodWithExtension => extensionMethods.extensionMethod(m) }
+    // }
+
+  }
+
+  /*
+   * Track the module-classes of static-modules that fulfill the criteria for "statification".
+   */
+  private def trackModuleClass(modClass: Symbol, modClassBT: BType) {
+    if(knownModClassStatification(modClassBT)) { return }
+    val isAnnotated = (modClass hasAnnotation definitions.ReallyStaticClass)
+    if(!isAnnotated || !isStatifiableModuleClass(modClass)) { return }
+    knownModClassStatification += modClassBT
+  }
+
+  /*
+   * @return true iff all of the conditions below hold:
+   *   (1) modClass is a static module
+   *   (2) modClass is direct subclass of AnyRef
+   *   (3) modClass doesn't extend any non-marker interfaces (thus, the members of the mod-class can be made static).
+   *
+   * Please notice the invoker has to test for the presence of @reallyStatic.
+   *
+   *  must-single-thread
+   *
+   */
+  private def isStatifiableModuleClass(modClass: Symbol): Boolean = {
+    val msg = impedimentsToStatifiabilityOfModuleClass(modClass)
+    if(msg == null) true
+    else { log(msg); false }
+  }
+
+  /*
+   * @return null iff the modClass is statifiable (please notice no check for @reallyStatic is performed here).
+   *                  Otherwise returns a String listing restrictions not fulfilled by modClass and that prevent statifiability.
+   */
+  def impedimentsToStatifiabilityOfModuleClass(modClass: Symbol): String = {
+    assert(modClass != NoSymbol)
+
+    var result: List[String] = Nil
+
+    if(modClass.isJavaDefined)    { result ::= "is a Java-defined class" }
+    if(!isStaticModule(modClass)) { result ::= "isn't a static module (ie has an outer-instance" }
+
+    val scSym = modClass.superClass
+    if(scSym != definitions.ObjectClass && scSym != NoSymbol) {
+      result ::= s"has a superClass other than AnyRef: ${scSym.fullName}"
+    }
+
+        def isMarkerInterface(isym: Symbol): Boolean = {
+          isym.info.declarations.isEmpty &&
+          (isym.mixinClasses forall isMarkerInterface)
+        }
+
+    val nonMarkerIfaces = modClass.mixinClasses filter { iface => !isMarkerInterface(iface) }
+    if(!nonMarkerIfaces.isEmpty) {
+      result ::= s"extends non-marker interfaces ${prettyPrintFullnames(nonMarkerIfaces)}"
+    }
+
+    if(result.isEmpty) null
+    else {
+      s"Won't statify the static module class of ${modClass.fullName} because it " + result.mkString(". Moreover, it ")
+    }
+  }
+
   // ---------------- utilities around interfaces represented by Tracked instances. ----------------
 
   /*  Drop redundant interfaces (those which are implemented by some other).

src/library/scala/reallyStatic.scala

@@ -0,0 +1,70 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2002-2013, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+\*                                                                      */
+
+package scala
+
+/**
+ * An annotation that indicates the static-module or value-class thus annotated
+ * will have only static members in the bytecode emitted for its module-class.
+ *
+ * The compiler accepts @reallyStatic occurrences provided the target module-class
+ * fulfills all of the following:
+ *   (1) the module-class is a static module
+ *   (2) the module-class is direct subclass of AnyRef
+ *   (3) the module-class extends either no interfaces or just marker interfaces
+ *
+ * With or without this annotation, a module-class allows accessing via MODULE$
+ * the singleton in question. However, @reallyStatic results in all callsites
+ * targeting that singleton being `invokestatic` instructions, ie the singleton is not loaded
+ * before any arguments. This may affect when the side-effects (if any) of the
+ * (static) class-initializer of the module-class become visible. In the simplest case,
+ * the class-initializer of a module-class just limits itself to assigning the singleton to MODULE$.
+ * But it's also possible for the class-initializer to perform more work, e.g. whenever
+ * the companion-object contains statements, or defines vals or vars.
+ *
+ * Finally, an object annotated with @reallyStatic that also defines @inline methods
+ * gives the inliner permission to replace an `invokestatic` (targeting the method in question) with its body,
+ * thus potentially skipping running the class-initializer for the associated module-class.
+ *
+ * The caveats above are listed for completeness. When used for its intended purpose, @reallyStatic is really useful!
+ *
+ * Before @reallyStatic, functionality defined on objects (and in the companion to value-classes) was accessed following the idiom:
+ *   load singleton-module
+ *   invokevirtual(arg1 ... argN)
+ * After JIT-compilation, performance is great because there's a single method method implementation to dispatch.
+ *
+ * However that could have been conveyed more directly by emitting "really static" methods, correspondinlgy invoked via invokestatic.
+ * This is what the @reallyStatic annotation allows,
+ * for a static module (ie an object definitions that lacks outer instance) or for a value class.
+ *
+ * In case the compiler can't honor the request for really-static-ness, a descriptive error message is shown.
+ * This can happen in two situations:
+ *
+ *   (a) extending another class:
+ *
+ *       {{{
+ *       @reallyStatic
+ *       case class Valued(val repr: Int) extends AnyVal {
+ *         def odd = (repr&1)==1
+ *       }
+ *
+ *       error: Won't statify the static module class of Valued because it has a superClass other than AnyRef: scala.runtime.AbstractFunction1
+ *       case class Valued(val repr: Int) extends AnyVal {
+ *                  ^
+ *       }}}
+ *
+ *   (b) extending non-marker interfaces
+ *
+ *       For example, a value-class that "extends AnyVal with Serializable" is ok,
+ *       but extending an interface that declares one or more members results in an error for an @reallyStatic-tagged class.
+ *
+ *
+ *  @author  Miguel Garcia, http://lampwww.epfl.ch/~magarcia/ScalaCompilerCornerReloaded/
+ *  @since   2.11
+ */
+class reallyStatic extends scala.annotation.StaticAnnotation

src/reflect/scala/reflect/internal/Definitions.scala

@@ -900,6 +900,7 @@ trait Definitions extends api.StandardDefinitions {
     lazy val UncheckedClass             = requiredClass[scala.unchecked]
     lazy val UnspecializedClass         = requiredClass[scala.annotation.unspecialized]
     lazy val VolatileAttr               = requiredClass[scala.volatile]
+    lazy val ReallyStaticClass          = requiredClass[scala.reallyStatic]
 
     // Meta-annotations
     lazy val BeanGetterTargetClass      = requiredClass[meta.beanGetter]