Factoring out methods used in backend. No direct usages of global anymore.

Author: DarkDimius

src/compiler/scala/tools/nsc/backend/ScalaPrimitives.scala

@@ -23,13 +23,13 @@ abstract class ICodes extends AnyRef
                                  with TypeStacks
                                  with TypeKinds
                                  with ExceptionHandlers
-                                 with Primitives
                                  with Linearizers
                                  with Printers
                                  with Repository
 {
   val global: Global
   import global.{ log, definitions, settings, perRunCaches, devWarning }
+  import Primitives._
 
   /** The ICode representation of classes */
   val classes = perRunCaches.newMap[global.Symbol, IClass]()

src/compiler/scala/tools/nsc/backend/icode/ICodes.scala

@@ -9,7 +9,7 @@ package backend
 package icode
 
 import scala.reflect.internal.util.{Position,NoPosition}
-
+import Primitives._
 /*
   A pattern match
 
@@ -66,6 +66,7 @@ import scala.reflect.internal.util.{Position,NoPosition}
  */
 trait Opcodes { self: ICodes =>
   import global.{Symbol, NoSymbol, Name, Constant}
+  import Opcodes._
 
   // categories of ICode instructions
   final val localsCat =  1
@@ -307,30 +308,30 @@ trait Opcodes { self: ICodes =>
       override def produced = 1
 
       override def consumedTypes = primitive match {
-        case Negation(kind)        => kind :: Nil
-        case Test(_, kind, true)   => kind :: Nil
-        case Test(_, kind, false)  => kind :: kind :: Nil
-        case Comparison(_, kind)   => kind :: kind :: Nil
-        case Arithmetic(NOT, kind) => kind :: Nil
-        case Arithmetic(_, kind)   => kind :: kind :: Nil
-        case Logical(_, kind)      => kind :: kind :: Nil
-        case Shift(_, kind)        => kind :: INT :: Nil
-        case Conversion(from, _)   => from :: Nil
-        case ArrayLength(kind)     => ARRAY(kind) :: Nil
-        case StringConcat(kind)    => ConcatClass :: kind :: Nil
+        case Negation(kind: Opcodes.this.TypeKind)        => kind :: Nil
+        case Test(_, kind: Opcodes.this.TypeKind, true)   => kind :: Nil
+        case Test(_, kind: Opcodes.this.TypeKind, false)  => kind :: kind :: Nil
+        case Comparison(_, kind: Opcodes.this.TypeKind)   => kind :: kind :: Nil
+        case Arithmetic(NOT, kind: Opcodes.this.TypeKind) => kind :: Nil
+        case Arithmetic(_, kind: Opcodes.this.TypeKind)   => kind :: kind :: Nil
+        case Logical(_, kind: Opcodes.this.TypeKind)      => kind :: kind :: Nil
+        case Shift(_, kind: Opcodes.this.TypeKind)        => kind :: INT :: Nil
+        case Conversion(from: Opcodes.this.TypeKind, _)   => from :: Nil
+        case ArrayLength(kind: Opcodes.this.TypeKind)     => ARRAY(kind) :: Nil
+        case StringConcat(kind: Opcodes.this.TypeKind)    => ConcatClass :: kind :: Nil
         case StartConcat           => Nil
         case EndConcat             => ConcatClass :: Nil
       }
 
       override def producedTypes = primitive match {
-        case Negation(kind)      => kind :: Nil
+        case Negation(kind: Opcodes.this.TypeKind)      => kind :: Nil
         case Test(_, _, true)    => BOOL :: Nil
         case Test(_, _, false)   => BOOL :: Nil
         case Comparison(_, _)    => INT :: Nil
-        case Arithmetic(_, kind) => kind :: Nil
-        case Logical(_, kind)    => kind :: Nil
-        case Shift(_, kind)      => kind :: Nil
-        case Conversion(_, to)   => to :: Nil
+        case Arithmetic(_, kind: Opcodes.this.TypeKind) => kind :: Nil
+        case Logical(_, kind: Opcodes.this.TypeKind)    => kind :: Nil
+        case Shift(_, kind: Opcodes.this.TypeKind)      => kind :: Nil
+        case Conversion(_, to: Opcodes.this.TypeKind)   => to :: Nil
         case ArrayLength(_)      => INT :: Nil
         case StringConcat(_)     => ConcatClass :: Nil
         case StartConcat         => ConcatClass :: Nil
@@ -716,52 +717,56 @@ trait Opcodes { self: ICodes =>
       override def producedTypes = REFERENCE(clasz) :: Nil
       override def category = stackCat
     }
+  }
+}
 
-    /** This class represents a method invocation style. */
-    sealed abstract class InvokeStyle {
-      /** Is this a dynamic method call? */
-      def isDynamic: Boolean = false
+object Opcodes{
 
-      /** Is this a static method call? */
-      def isStatic: Boolean = false
+  /** This class represents a method invocation style. */
+  sealed abstract class InvokeStyle {
+    /** Is this a dynamic method call? */
+    def isDynamic: Boolean = false
 
-      def isSuper: Boolean = false
+    /** Is this a static method call? */
+    def isStatic: Boolean = false
 
-      /** Is this an instance method call? */
-      def hasInstance: Boolean = true
+    def isSuper: Boolean = false
 
-      /** Returns a string representation of this style. */
-      override def toString(): String
-    }
+    /** Is this an instance method call? */
+    def hasInstance: Boolean = true
 
-    /** Virtual calls.
-     *  On JVM, translated to either `invokeinterface` or `invokevirtual`.
-     */
-    case object Dynamic extends InvokeStyle {
-      override def isDynamic = true
-      override def toString(): String = "dynamic"
-    }
+    /** Returns a string representation of this style. */
+    override def toString(): String
+  }
 
-    /**
-     * Special invoke:
-     *   Static(true)  is used for calls to private members, ie `invokespecial` on JVM.
-     *   Static(false) is used for calls to class-level instance-less static methods, ie `invokestatic` on JVM.
-     */
-    case class Static(onInstance: Boolean) extends InvokeStyle {
-      override def isStatic    = true
-      override def hasInstance = onInstance
-      override def toString(): String = {
-        if(onInstance) "static-instance"
-        else           "static-class"
-      }
-    }
+  /** Virtual calls.
+    *  On JVM, translated to either `invokeinterface` or `invokevirtual`.
+    */
+  case object Dynamic extends InvokeStyle {
+    override def isDynamic = true
+    override def toString(): String = "dynamic"
+  }
 
-    /** Call through super[mix].
-     *  On JVM, translated to `invokespecial`.
-     */
-    case class SuperCall(mix: Name) extends InvokeStyle {
-      override def isSuper = true
-      override def toString(): String = { "super(" + mix + ")" }
+  /**
+   * Special invoke:
+   *   Static(true)  is used for calls to private members, ie `invokespecial` on JVM.
+   *   Static(false) is used for calls to class-level instance-less static methods, ie `invokestatic` on JVM.
+   */
+  case class Static(onInstance: Boolean) extends InvokeStyle {
+    override def isStatic    = true
+    override def hasInstance = onInstance
+    override def toString(): String = {
+      if(onInstance) "static-instance"
+      else           "static-class"
     }
   }
+
+  /** Call through super[mix].
+    *  On JVM, translated to `invokespecial`.
+    */
+  case class SuperCall(mix: String) extends InvokeStyle {
+    override def isSuper = true
+    override def toString(): String = { "super(" + mix + ")" }
+  }
+
 }

src/compiler/scala/tools/nsc/backend/icode/Opcodes.scala

@@ -10,8 +10,7 @@ package icode
 
 import java.io.PrintWriter
 
-trait Primitives { self: ICodes =>
-
+object Primitives {
   /** This class represents a primitive operation. */
   class Primitive {
   }
@@ -20,48 +19,48 @@ trait Primitives { self: ICodes =>
   // type : (type) => type
   // range: type <- { BOOL, Ix, Ux, Rx }
   // jvm  : {i, l, f, d}neg
-  case class Negation(kind: TypeKind) extends Primitive
+  case class Negation(kind: TypeKinds#TypeKind) extends Primitive
 
   // type : zero ? (type) => BOOL : (type,type) => BOOL
   // range: type <- { BOOL, Ix, Ux, Rx, REF }
   // jvm  : if{eq, ne, lt, ge, le, gt}, if{null, nonnull}
   //        if_icmp{eq, ne, lt, ge, le, gt}, if_acmp{eq,ne}
-  case class Test(op: TestOp, kind: TypeKind,  zero: Boolean)  extends Primitive
+  case class Test(op: TestOp, kind: TypeKinds#TypeKind,  zero: Boolean)  extends Primitive
 
   // type : (type,type) => I4
   // range: type <- { Ix, Ux, Rx }
   // jvm  : lcmp, {f, d}cmp{l, g}
-  case class Comparison(op: ComparisonOp, kind: TypeKind) extends Primitive
+  case class Comparison(op: ComparisonOp, kind: TypeKinds#TypeKind) extends Primitive
 
   // type : (type,type) => type
   // range: type <- { Ix, Ux, Rx }
   // jvm  : {i, l, f, d}{add, sub, mul, div, rem}
-  case class Arithmetic(op: ArithmeticOp, kind: TypeKind) extends Primitive
+  case class Arithmetic(op: ArithmeticOp, kind: TypeKinds#TypeKind) extends Primitive
 
   // type : (type,type) => type
   // range: type <- { BOOL, Ix, Ux }
   // jvm  : {i, l}{and, or, xor}
-  case class Logical(op: LogicalOp, kind: TypeKind) extends Primitive
+  case class Logical(op: LogicalOp, kind: TypeKinds#TypeKind) extends Primitive
 
   // type : (type,I4) => type
   // range: type <- { Ix, Ux }
   // jvm  : {i, l}{shl, ushl, shr}
-  case class Shift(op: ShiftOp, kind: TypeKind) extends Primitive
+  case class Shift(op: ShiftOp, kind: TypeKinds#TypeKind) extends Primitive
 
   // type : (src) => dst
   // range: src,dst <- { Ix, Ux, Rx }
   // jvm  : i2{l, f, d}, l2{i, f, d}, f2{i, l, d}, d2{i, l, f}, i2{b, c, s}
-  case class Conversion(src: TypeKind, dst: TypeKind) extends Primitive
+  case class Conversion(src: TypeKinds#TypeKind, dst: TypeKinds#TypeKind) extends Primitive
 
   // type : (Array[REF]) => I4
   // range: type <- { BOOL, Ix, Ux, Rx, REF }
   // jvm  : arraylength
-  case class ArrayLength(kind: TypeKind) extends Primitive
+  case class ArrayLength(kind: TypeKinds#TypeKind) extends Primitive
 
   // type : (buf,el) => buf
   // range: lf,rg <- { BOOL, Ix, Ux, Rx, REF, STR }
   // jvm  : It should call the appropiate 'append' method on StringBuffer
-  case class StringConcat(el: TypeKind) extends Primitive
+  case class StringConcat(el: TypeKinds#TypeKind) extends Primitive
 
   /** Signals the beginning of a series of concatenations.
    *  On the JVM platform, it should create a new StringBuffer

src/compiler/scala/tools/nsc/backend/icode/Primitives.scala

@@ -7,6 +7,8 @@ package scala.tools.nsc
 package backend
 package icode
 
+import scala.tools.nsc.backend.jvm.BackendInterface
+
 /* A type case
 
     case UNIT            =>

src/compiler/scala/tools/nsc/backend/icode/TypeKinds.scala

@@ -5,21 +5,15 @@
 
 package scala.tools.nsc.backend.jvm
 
+import scala.reflect.internal.AnnotationInfos
 import scala.tools.nsc.Global
 
 /**
  * This trait contains code shared between GenBCode and GenASM that depends on types defined in
  * the compiler cake (Global).
  */
-final class BCodeAsmCommon[G <: Global](val global: G) {
-  import global._
-  import definitions._
-
-  val ExcludedForwarderFlags = {
-    import scala.tools.nsc.symtab.Flags._
-    // Should include DEFERRED but this breaks findMember.
-    SPECIALIZED | LIFTED | PROTECTED | STATIC | EXPANDEDNAME | BridgeAndPrivateFlags | MACRO
-  }
+final class BCodeAsmCommon[I <: BackendInterface](interface: I) {
+import interface._
 
   /**
    * True if `classSym` is an anonymous class or a local class. I.e., false if `classSym` is a
@@ -103,63 +97,58 @@ final class BCodeAsmCommon[G <: Global](val global: G) {
       None
     }
   }
+}
 
-  /**
-   * This is basically a re-implementation of sym.isStaticOwner, but using the originalOwner chain.
-   *
-   * The problem is that we are interested in a source-level property. Various phases changed the
-   * symbol's properties in the meantime, mostly lambdalift modified (destructively) the owner.
-   * Therefore, `sym.isStatic` is not what we want. For example, in
-   *   object T { def f { object U } }
-   * the owner of U is T, so UModuleClass.isStatic is true. Phase travel does not help here.
-   */
-  def isOriginallyStaticOwner(sym: Symbol): Boolean = {
-    sym.isPackageClass || sym.isModuleClass && isOriginallyStaticOwner(sym.originalOwner)
-  }
-
-  /**
-   * The member classes of a class symbol. Note that the result of this method depends on the
-   * current phase, for example, after lambdalift, all local classes become member of the enclosing
-   * class.
-   */
-  def memberClassesOf(classSymbol: Symbol): List[Symbol] = classSymbol.info.decls.collect({
-    case sym if sym.isClass =>
-      sym
-    case sym if sym.isModule =>
-      val r = exitingPickler(sym.moduleClass)
-      assert(r != NoSymbol, sym.fullLocationString)
-      r
-  })(collection.breakOut)
-
-  lazy val AnnotationRetentionPolicyModule       = AnnotationRetentionPolicyAttr.companionModule
-  lazy val AnnotationRetentionPolicySourceValue  = AnnotationRetentionPolicyModule.tpe.member(TermName("SOURCE"))
-  lazy val AnnotationRetentionPolicyClassValue   = AnnotationRetentionPolicyModule.tpe.member(TermName("CLASS"))
-  lazy val AnnotationRetentionPolicyRuntimeValue = AnnotationRetentionPolicyModule.tpe.member(TermName("RUNTIME"))
+object BCodeAsmCommon{
+  def ubytesToCharArray(bytes: Array[Byte]): Array[Char] = {
+    val ca = new Array[Char](bytes.length)
+    var idx = 0
+    while(idx < bytes.length) {
+      val b: Byte = bytes(idx)
+      assert((b & ~0x7f) == 0)
+      ca(idx) = b.asInstanceOf[Char]
+      idx += 1
+    }
 
-  /** Whether an annotation should be emitted as a Java annotation
-    * .initialize: if 'annot' is read from pickle, atp might be un-initialized
-    */
-  def shouldEmitAnnotation(annot: AnnotationInfo) = {
-    annot.symbol.initialize.isJavaDefined &&
-      annot.matches(ClassfileAnnotationClass) &&
-      retentionPolicyOf(annot) != AnnotationRetentionPolicySourceValue &&
-      annot.args.isEmpty
+    ca
   }
 
-  def isRuntimeVisible(annot: AnnotationInfo): Boolean = {
-    annot.atp.typeSymbol.getAnnotation(AnnotationRetentionAttr) match {
-      case Some(retentionAnnot) =>
-        retentionAnnot.assocs.contains(nme.value -> LiteralAnnotArg(Constant(AnnotationRetentionPolicyRuntimeValue)))
-      case _ =>
-        // SI-8926: if the annotation class symbol doesn't have a @RetentionPolicy annotation, the
-        // annotation is emitted with visibility `RUNTIME`
-        true
+  final def arrEncode(sb: AnnotationInfos#ScalaSigBytes): Array[String] = {
+    var strs: List[String]  = Nil
+    val bSeven: Array[Byte] = sb.sevenBitsMayBeZero
+    // chop into slices of at most 65535 bytes, counting 0x00 as taking two bytes (as per JVMS 4.4.7 The CONSTANT_Utf8_info Structure)
+    var prevOffset = 0
+    var offset     = 0
+    var encLength  = 0
+    while(offset < bSeven.length) {
+      val deltaEncLength = (if(bSeven(offset) == 0) 2 else 1)
+      val newEncLength = encLength.toLong + deltaEncLength
+      if(newEncLength >= 65535) {
+        val ba     = bSeven.slice(prevOffset, offset)
+        strs     ::= new java.lang.String(ubytesToCharArray(ba))
+        encLength  = 0
+        prevOffset = offset
+      } else {
+        encLength += deltaEncLength
+        offset    += 1
+      }
     }
+    if(prevOffset < offset) {
+      assert(offset == bSeven.length)
+      val ba = bSeven.slice(prevOffset, offset)
+      strs ::= new java.lang.String(ubytesToCharArray(ba))
+    }
+    assert(strs.size > 1, "encode instead as one String via strEncode()") // TODO too strict?
+    strs.reverse.toArray
   }
 
-  private def retentionPolicyOf(annot: AnnotationInfo): Symbol =
-    annot.atp.typeSymbol.getAnnotation(AnnotationRetentionAttr).map(_.assocs).map(assoc =>
-      assoc.collectFirst {
-        case (`nme`.value, LiteralAnnotArg(Constant(value: Symbol))) => value
-      }).flatten.getOrElse(AnnotationRetentionPolicyClassValue)
-}
+
+  def strEncode(sb: AnnotationInfos#ScalaSigBytes): String = {
+    val ca = ubytesToCharArray(sb.sevenBitsMayBeZero)
+    new java.lang.String(ca)
+    // debug val bvA = new asm.ByteVector; bvA.putUTF8(s)
+    // debug val enc: Array[Byte] = scala.reflect.internal.pickling.ByteCodecs.encode(bytes)
+    // debug assert(enc(idx) == bvA.getByte(idx + 2))
+    // debug assert(bvA.getLength == enc.size + 2)
+  }
+}