Move methods

Author: nicolasstucki

compiler/src/dotty/tools/backend/jvm/BCodeBodyBuilder.scala

@@ -1351,7 +1351,15 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
        */
       val mustUseAnyComparator: Boolean = {
         val areSameFinals = l.tpe.typeSymbol.is(Flags.Final) && r.tpe.typeSymbol.is(Flags.Final) && (l.tpe =:= r.tpe)
-
+        // todo: remove
+        def isMaybeBoxed(sym: Symbol): Boolean = {
+          (sym == defn.ObjectClass) ||
+            (sym == defn.JavaSerializableClass) ||
+            (sym == defn.ComparableClass) ||
+            (sym derivesFrom defn.BoxedNumberClass) ||
+            (sym derivesFrom defn.BoxedCharClass) ||
+            (sym derivesFrom defn.BoxedBooleanClass)
+        }
         !areSameFinals && isMaybeBoxed(l.tpe.widenDealias.typeSymbol) && isMaybeBoxed(r.tpe.widenDealias.typeSymbol)
       }
       def isNull(t: Tree): Boolean = t match {

compiler/src/dotty/tools/backend/jvm/BCodeHelpers.scala

@@ -17,9 +17,11 @@ import dotty.tools.dotc.core.Decorators._
 import dotty.tools.dotc.core.Flags
 import dotty.tools.dotc.core.Names.Name
 import dotty.tools.dotc.core.NameKinds.ExpandedName
-import dotty.tools.dotc.core.Symbols._
+import dotty.tools.dotc.core.Signature
 import dotty.tools.dotc.core.StdNames._
+import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.core.Types
+import dotty.tools.dotc.core.Types._
 
 /*
  *  Traits encapsulating functionality to convert Scala AST Trees into ASM ClassNodes.
@@ -183,7 +185,7 @@ trait BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
 
   trait BCInnerClassGen {
 
-    def debugLevel = int.debuglevel
+    def debugLevel = 3 // 0 -> no debug info; 1-> filename; 2-> lines; 3-> varnames
 
     final val emitSource = debugLevel >= 1
     final val emitLines  = debugLevel >= 2
@@ -323,6 +325,12 @@ trait BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
         emitAssocs(pannVisitor, assocs, BCodeHelpers.this)(this)
       }
 
+
+    private def shouldEmitAnnotation(annot: Annotation): Boolean = {
+      annot.symbol.is(Flags.JavaDefined) &&
+        retentionPolicyOf(annot) != AnnotationRetentionSourceAttr
+    }
+
     private def emitAssocs(av: asm.AnnotationVisitor, assocs: List[(Name, Object)], bcodeStore: BCodeHelpers)
         (innerClasesStore: bcodeStore.BCInnerClassGen) = {
       for ((name, value) <- assocs)
@@ -412,6 +420,20 @@ trait BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
       case _ => arg
     }
 
+    private def isRuntimeVisible(annot: Annotation): Boolean =
+      if (toDenot(annot.tree.tpe.typeSymbol).hasAnnotation(AnnotationRetentionAttr))
+        retentionPolicyOf(annot) == AnnotationRetentionRuntimeAttr
+      else {
+        // SI-8926: if the annotation class symbol doesn't have a @RetentionPolicy annotation, the
+        // annotation is emitted with visibility `RUNTIME`
+        // dotty bug: #389
+        true
+      }
+
+    private def retentionPolicyOf(annot: Annotation): Symbol =
+      annot.tree.tpe.typeSymbol.getAnnotation(AnnotationRetentionAttr).
+        flatMap(_.argumentConstant(0).map(_.symbolValue)).getOrElse(AnnotationRetentionClassAttr)
+
   } // end of trait BCAnnotGen
 
   trait BCJGenSigGen {
@@ -527,6 +549,20 @@ trait BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
       }
     }
 
+    /** The members of this type that have all of `required` flags but none of `excluded` flags set.
+     *  The members are sorted by name and signature to guarantee a stable ordering.
+     */
+    private def sortedMembersBasedOnFlags(tp: Type, required: Flags.Flag, excluded: Flags.FlagSet): List[Symbol] = {
+      // The output of `memberNames` is a Set, sort it to guarantee a stable ordering.
+      val names = tp.memberNames(takeAllFilter).toSeq.sorted
+      val buffer = mutable.ListBuffer[Symbol]()
+      names.foreach { name =>
+        buffer ++= tp.memberBasedOnFlags(name, required, excluded)
+          .alternatives.sortBy(_.signature)(Signature.lexicographicOrdering).map(_.symbol)
+      }
+      buffer.toList
+    }
+
     /*
      * Quoting from JVMS 4.7.5 The Exceptions Attribute
      *   "The Exceptions attribute indicates which checked exceptions a method may throw.

compiler/src/dotty/tools/backend/jvm/BTypesFromSymbols.scala

@@ -7,6 +7,7 @@ import scala.annotation.threadUnsafe
 
 import dotty.tools.dotc.core.Flags
 import dotty.tools.dotc.core.Symbols._
+import dotty.tools.dotc.transform.SymUtils._
 
 /**
  * This class mainly contains the method classBTypeFromSymbol, which extracts the necessary
@@ -89,7 +90,22 @@ class BTypesFromSymbols[I <: DottyBackendInterface](val int: I) extends BTypes {
     val superClass = if (superClassSym == NoSymbol) None
                      else Some(classBTypeFromSymbol(superClassSym))
 
-    val interfaces = symHelper(classSym).superInterfaces.map(classBTypeFromSymbol)
+    /**
+     * All interfaces implemented by a class, except for those inherited through the superclass.
+     * Redundant interfaces are removed unless there is a super call to them.
+     */
+    def (sym: Symbol).superInterfaces: List[Symbol] = {
+      val directlyInheritedTraits = sym.directlyInheritedTraits
+      val directlyInheritedTraitsSet = directlyInheritedTraits.toSet
+      val allBaseClasses = directlyInheritedTraits.iterator.flatMap(_.asClass.baseClasses.drop(1)).toSet
+      val superCalls = superCallsMap.getOrElse(sym, Set.empty)
+      val additional = (superCalls -- directlyInheritedTraitsSet).filter(_.is(Flags.Trait))
+//      if (additional.nonEmpty)
+//        println(s"$fullName: adding supertraits $additional")
+      directlyInheritedTraits.filter(t => !allBaseClasses(t) || superCalls(t)) ++ additional
+    }
+
+    val interfaces = classSym.superInterfaces.map(classBTypeFromSymbol)
 
     val flags = javaFlags(classSym)
 
@@ -166,7 +182,7 @@ class BTypesFromSymbols[I <: DottyBackendInterface](val int: I) extends BTypes {
     if (!isNested) None
     else {
       // See comment in BTypes, when is a class marked static in the InnerClass table.
-      val isStaticNestedClass = symHelper(symHelper(innerClassSym.originalOwner).originalLexicallyEnclosingClass).isOriginallyStaticOwner
+      val isStaticNestedClass = symHelper(innerClassSym.originalOwner).originalLexicallyEnclosingClass.isOriginallyStaticOwner
 
       // After lambdalift (which is where we are), the rawowoner field contains the enclosing class.
       val enclosingClassSym = {
@@ -184,6 +200,8 @@ class BTypesFromSymbols[I <: DottyBackendInterface](val int: I) extends BTypes {
           None
         } else {
           val outerName = symHelper(innerClassSym.originalOwner).originalLexicallyEnclosingClass.fullName.mangledString.replace('.', '/')
+          def dropModule(str: String): String =
+            if (!str.isEmpty && str.last == '$') str.take(str.length - 1) else str
           // Java compatibility. See the big comment in BTypes that summarizes the InnerClass spec.
           val outerNameModule =
             if (symHelper(symHelper(innerClassSym.originalOwner).originalLexicallyEnclosingClass).isTopLevelModuleClass) dropModule(outerName)
@@ -204,6 +222,18 @@ class BTypesFromSymbols[I <: DottyBackendInterface](val int: I) extends BTypes {
     }
   }
 
+  /**
+   * 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.
+   */
+  private def (sym: Symbol).isOriginallyStaticOwner: Boolean =
+    sym.is(Flags.PackageClass) || sym.is(Flags.ModuleClass) && symHelper(sym.originalOwner).originalLexicallyEnclosingClass.isOriginallyStaticOwner
+
   /**
    * Return the Java modifiers for the given symbol.
    * Java modifiers for classes:

compiler/src/dotty/tools/backend/jvm/BytecodeWriters.scala

@@ -35,7 +35,7 @@ trait BytecodeWriters {
 
   def factoryNonJarBytecodeWriter(): BytecodeWriter = {
     val emitAsmp  = None
-    val doDump    = int.dumpClasses
+    val doDump    = dumpClasses
     (emitAsmp.isDefined, doDump.isDefined) match {
       case (false, false) => new ClassBytecodeWriter { }
       case (false, true ) => new ClassBytecodeWriter with DumpBytecodeWriter { }
@@ -116,7 +116,7 @@ trait BytecodeWriters {
   }
 
   trait DumpBytecodeWriter extends BytecodeWriter {
-    val baseDir = Directory(int.dumpClasses.get).createDirectory()
+    val baseDir = Directory(dumpClasses.get).createDirectory()
 
     abstract override def writeClass(label: String, jclassName: String, jclassBytes: Array[Byte], outfile: AbstractFile): Unit = {
       super.writeClass(label, jclassName, jclassBytes, outfile)
@@ -130,4 +130,8 @@ trait BytecodeWriters {
       finally outstream.close()
     }
   }
+
+  private def dumpClasses: Option[String] =
+    if (ctx.settings.Ydumpclasses.isDefault) None
+    else Some(ctx.settings.Ydumpclasses.value)
 }

compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala

@@ -57,25 +57,6 @@ class DottyBackendInterface(val outputDirectory: AbstractFile, val superCallsMap
 
   val primitives = new DottyPrimitives(ctx)
 
-  def isRuntimeVisible(annot: Annotation): Boolean =
-    if (toDenot(annot.tree.tpe.typeSymbol).hasAnnotation(AnnotationRetentionAttr))
-      retentionPolicyOf(annot) == AnnotationRetentionRuntimeAttr
-    else {
-      // SI-8926: if the annotation class symbol doesn't have a @RetentionPolicy annotation, the
-      // annotation is emitted with visibility `RUNTIME`
-      // dotty bug: #389
-      true
-    }
-
-  def shouldEmitAnnotation(annot: Annotation): Boolean = {
-    annot.symbol.is(Flags.JavaDefined) &&
-      retentionPolicyOf(annot) != AnnotationRetentionSourceAttr
-  }
-
-  private def retentionPolicyOf(annot: Annotation): Symbol =
-    annot.tree.tpe.typeSymbol.getAnnotation(AnnotationRetentionAttr).
-      flatMap(_.argumentConstant(0).map(_.symbolValue)).getOrElse(AnnotationRetentionClassAttr)
-
   private def erasureString(clazz: Class[_]): String = {
     if (clazz.isArray) "Array[" + erasureString(clazz.getComponentType) + "]"
     else clazz.getName
@@ -97,12 +78,6 @@ class DottyBackendInterface(val outputDirectory: AbstractFile, val superCallsMap
   def sourcePos(pos: Spans.Span)(implicit ctx: Context): util.SourcePosition =
     ctx.source.atSpan(pos)
 
-  def dumpClasses: Option[String] =
-    if (ctx.settings.Ydumpclasses.isDefault) None
-    else Some(ctx.settings.Ydumpclasses.value)
-
-  def debuglevel: Int = 3 // 0 -> no debug info; 1-> filename; 2-> lines; 3-> varnames
-
   val perRunCaches: Caches = new Caches {
     def newAnyRefMap[K <: AnyRef, V](): mutable.AnyRefMap[K, V] = new mutable.AnyRefMap[K, V]()
     def newWeakMap[K, V](): mutable.WeakHashMap[K, V] = new mutable.WeakHashMap[K, V]()
@@ -112,9 +87,6 @@ class DottyBackendInterface(val outputDirectory: AbstractFile, val superCallsMap
     def newSet[K](): mutable.Set[K] = new mutable.HashSet[K]
   }
 
-  def dropModule(str: String): String =
-    if (!str.isEmpty && str.last == '$') str.take(str.length - 1) else str
-
   private val desugared = new java.util.IdentityHashMap[Type, tpd.Select]
 
   def desugarIdentBI(i: Ident): Option[tpd.Select] = {
@@ -130,16 +102,6 @@ class DottyBackendInterface(val outputDirectory: AbstractFile, val superCallsMap
     if (found == null) None else Some(found)
   }
 
-  // todo: remove
-  def isMaybeBoxed(sym: Symbol): Boolean = {
-    (sym == defn.ObjectClass) ||
-      (sym == defn.JavaSerializableClass) ||
-      (sym == defn.ComparableClass) ||
-      (sym derivesFrom defn.BoxedNumberClass) ||
-      (sym derivesFrom defn.BoxedCharClass) ||
-      (sym derivesFrom defn.BoxedBooleanClass)
-  }
-
   // @M don't generate java generics sigs for (members of) implementation
   // classes, as they are monomorphic (TODO: ok?)
   private final def needsGenericSignature(sym: Symbol): Boolean = !(
@@ -318,21 +280,6 @@ class DottyBackendInterface(val outputDirectory: AbstractFile, val superCallsMap
         }
       else Nil
 
-    /**
-     * All interfaces implemented by a class, except for those inherited through the superclass.
-     * Redundant interfaces are removed unless there is a super call to them.
-     */
-    def superInterfaces: List[Symbol] = {
-      val directlyInheritedTraits = decorateSymbol(sym).directlyInheritedTraits
-      val directlyInheritedTraitsSet = directlyInheritedTraits.toSet
-      val allBaseClasses = directlyInheritedTraits.iterator.flatMap(_.asClass.baseClasses.drop(1)).toSet
-      val superCalls = superCallsMap.getOrElse(sym, Set.empty)
-      val additional = (superCalls -- directlyInheritedTraitsSet).filter(_.is(Flags.Trait))
-//      if (additional.nonEmpty)
-//        println(s"$fullName: adding supertraits $additional")
-      directlyInheritedTraits.filter(t => !allBaseClasses(t) || superCalls(t)) ++ additional
-    }
-
     /**
      * True for module classes of package level objects. The backend will generate a mirror class for
      * such objects.
@@ -353,33 +300,6 @@ class DottyBackendInterface(val outputDirectory: AbstractFile, val superCallsMap
       }
     }
 
-
-    /**
-     * 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: Boolean =
-      sym.is(Flags.PackageClass) || sym.is(Flags.ModuleClass) && symHelper(symHelper(sym.originalOwner).originalLexicallyEnclosingClass).isOriginallyStaticOwner
-  }
-
-
-  /** The members of this type that have all of `required` flags but none of `excluded` flags set.
-   *  The members are sorted by name and signature to guarantee a stable ordering.
-   */
-  def sortedMembersBasedOnFlags(tp: Type, required: Flags.Flag, excluded: Flags.FlagSet): List[Symbol] = {
-    // The output of `memberNames` is a Set, sort it to guarantee a stable ordering.
-    val names = tp.memberNames(takeAllFilter).toSeq.sorted
-    val buffer = mutable.ListBuffer[Symbol]()
-    names.foreach { name =>
-      buffer ++= tp.memberBasedOnFlags(name, required, excluded)
-        .alternatives.sortBy(_.signature)(Signature.lexicographicOrdering).map(_.symbol)
-    }
-    buffer.toList
   }
 
   object SelectBI extends DeconstructorCommon[tpd.Tree] {