Merge pull request #8499 from dotty-staging/backend-call-receiver

backend: Emit calls using the correct receiver

Author: smarter

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

@@ -6,6 +6,7 @@ import scala.tools.asm
 import scala.annotation.switch
 import scala.collection.mutable
 import Primitives.{NE, EQ, TestOp, ArithmeticOp}
+import scala.tools.asm.tree.MethodInsnNode
 
 /*
  *  A high-level facade to the ASM API for bytecode generation.
@@ -104,7 +105,7 @@ trait BCodeIdiomatic {
    */
   abstract class JCodeMethodN {
 
-    def jmethod: asm.MethodVisitor
+    def jmethod: asm.tree.MethodNode
 
     import asm.Opcodes;
 
@@ -394,21 +395,27 @@ trait BCodeIdiomatic {
 
     // can-multi-thread
     final def invokespecial(owner: String, name: String, desc: String, itf: Boolean): Unit = {
-      jmethod.visitMethodInsn(Opcodes.INVOKESPECIAL, owner, name, desc, itf)
+      emitInvoke(Opcodes.INVOKESPECIAL, owner, name, desc, itf)
     }
     // can-multi-thread
     final def invokestatic(owner: String, name: String, desc: String, itf: Boolean): Unit = {
-      jmethod.visitMethodInsn(Opcodes.INVOKESTATIC, owner, name, desc, itf)
+      emitInvoke(Opcodes.INVOKESTATIC, owner, name, desc, itf)
     }
     // can-multi-thread
     final def invokeinterface(owner: String, name: String, desc: String): Unit = {
-      jmethod.visitMethodInsn(Opcodes.INVOKEINTERFACE, owner, name, desc, true)
+      emitInvoke(Opcodes.INVOKEINTERFACE, owner, name, desc, itf = true)
     }
     // can-multi-thread
     final def invokevirtual(owner: String, name: String, desc: String): Unit = {
-      jmethod.visitMethodInsn(Opcodes.INVOKEVIRTUAL, owner, name, desc, false)
+      emitInvoke(Opcodes.INVOKEVIRTUAL, owner, name, desc, itf = false)
     }
 
+    def emitInvoke(opcode: Int, owner: String, name: String, desc: String, itf: Boolean): Unit = {
+      val node = new MethodInsnNode(opcode, owner, name, desc, itf)
+      jmethod.instructions.add(node)
+    }
+
+
     // can-multi-thread
     final def goTo(label: asm.Label): Unit = { jmethod.visitJumpInsn(Opcodes.GOTO, label) }
     // can-multi-thread

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

@@ -49,7 +49,7 @@ class BTypesFromSymbols[I <: BackendInterface](val int: I) extends BTypes {
     assert(
       (!primitiveTypeMap.contains(classSym) || isCompilingPrimitive) &&
       (classSym != NothingClass && classSym != NullClass),
-      s"Cannot create ClassBType for special class symbol ${classSym.fullName}")
+      s"Cannot create ClassBType for special class symbol ${classSym.showFullName}")
 
     convertedClasses.getOrElse(classSym, {
       val internalName = classSym.javaBinaryName

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

@@ -442,10 +442,10 @@ abstract class BackendInterface extends BackendInterfaceDefinitions {
   }
 
   abstract class SymbolHelper {
+    def exists: Boolean
+
     // names
-    def fullName(sep: Char): String
-    def fullName: String
-    def simpleName: Name
+    def showFullName: String
     def javaSimpleName: String
     def javaBinaryName: String
     def javaClassName: String
@@ -460,10 +460,11 @@ abstract class BackendInterface extends BackendInterfaceDefinitions {
     /** Does this symbol actually correspond to an interface that will be emitted?
      *  In the backend, this should be preferred over `isInterface` because it
      *  also returns true for the symbols of the fake companion objects we
-     *  create for Java-defined classes.
+     *  create for Java-defined classes as well as for Java annotations
+     *  which we represent as classes.
      */
     final def isEmittedInterface: Boolean = isInterface ||
-      isJavaDefined && isModuleClass && companionClass.isInterface
+      isJavaDefined && (isAnnotation || isModuleClass && companionClass.isInterface)
 
     // tests
     def isClass: Boolean
@@ -491,6 +492,7 @@ abstract class BackendInterface extends BackendInterfaceDefinitions {
     def getsJavaPrivateFlag: Boolean
     def isFinal: Boolean
     def getsJavaFinalFlag: Boolean
+    def isScalaStatic: Boolean
     def isStaticMember: Boolean
     def isBottomClass: Boolean
     def isBridge: Boolean
@@ -508,6 +510,7 @@ abstract class BackendInterface extends BackendInterfaceDefinitions {
     def shouldEmitForwarders: Boolean
     def isJavaDefaultMethod: Boolean
     def isClassConstructor: Boolean
+    def isAnnotation: Boolean
     def isSerializable: Boolean
     def isEnum: Boolean
 
@@ -536,6 +539,7 @@ abstract class BackendInterface extends BackendInterfaceDefinitions {
     def enclosingClassSym: Symbol
     def originalLexicallyEnclosingClass: Symbol
     def nextOverriddenSymbol: Symbol
+    def allOverriddenSymbols: List[Symbol]
 
 
     // members
@@ -605,6 +609,7 @@ abstract class BackendInterface extends BackendInterfaceDefinitions {
      */
     def sortedMembersBasedOnFlags(required: Flags, excluded: Flags): List[Symbol]
     def members: List[Symbol]
+    def decl(name: Name): Symbol
     def decls: List[Symbol]
     def underlying: Type
     def parents: List[Type]

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

@@ -627,10 +627,10 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
   }
 
   implicit def symHelper(sym: Symbol): SymbolHelper = new SymbolHelper {
+    def exists: Boolean = sym.exists
+
     // names
-    def fullName(sep: Char): String = sym.showFullName
-    def fullName: String = sym.showFullName
-    def simpleName: Name = sym.name
+    def showFullName: String = sym.showFullName
     def javaSimpleName: String = toDenot(sym).name.mangledString // addModuleSuffix(simpleName.dropLocal)
     def javaBinaryName: String = javaClassName.replace('.', '/') // TODO: can we make this a string? addModuleSuffix(fullNameInternal('/'))
     def javaClassName: String = toDenot(sym).fullName.mangledString // addModuleSuffix(fullNameInternal('.')).toString
@@ -678,11 +678,13 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
       isPrivate || (sym.isPrimaryConstructor && sym.owner.isTopLevelModuleClass)
 
     def isFinal: Boolean = sym.is(Flags.Final)
+    def isScalaStatic: Boolean =
+      toDenot(sym).hasAnnotation(ctx.definitions.ScalaStaticAnnot)
     def isStaticMember: Boolean = (sym ne NoSymbol) &&
-      (sym.is(Flags.JavaStatic) || toDenot(sym).hasAnnotation(ctx.definitions.ScalaStaticAnnot))
+      (sym.is(Flags.JavaStatic) || isScalaStatic)
       // guard against no sumbol cause this code is executed to select which call type(static\dynamic) to use to call array.clone
 
-    def isBottomClass: Boolean = (sym ne defn.NullClass) && (sym ne defn.NothingClass)
+    def isBottomClass: Boolean = (sym eq defn.NullClass) || (sym eq defn.NothingClass)
     def isBridge: Boolean = sym.is(Flags.Bridge)
     def isArtifact: Boolean = sym.is(Flags.Artifact)
     def hasEnumFlag: Boolean = sym.isAllOf(Flags.JavaEnumTrait)
@@ -700,6 +702,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
     def isEnum = sym.is(Flags.Enum)
 
     def isClassConstructor: Boolean = toDenot(sym).isClassConstructor
+    def isAnnotation: Boolean = toDenot(sym).isAnnotation
     def isSerializable: Boolean = toDenot(sym).isSerializable
 
     /**
@@ -761,12 +764,14 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
         toDenot(sym)(shiftedContext).lexicallyEnclosingClass(shiftedContext)
       } else NoSymbol
     def nextOverriddenSymbol: Symbol = toDenot(sym).nextOverriddenSymbol
+    def allOverriddenSymbols: List[Symbol] = toDenot(sym).allOverriddenSymbols.toList
 
     // members
     def primaryConstructor: Symbol = toDenot(sym).primaryConstructor
 
     /** For currently compiled classes: All locally defined classes including local classes.
      *  The empty list for classes that are not currently compiled.
+
      */
     def nestedClasses: List[Symbol] = definedClasses(ctx.flattenPhase)
 
@@ -878,6 +883,8 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
 
     def memberInfo(s: Symbol): Type = tp.memberInfo(s)
 
+    def decl(name: Name): Symbol = tp.decl(name).symbol
+
     def decls: List[Symbol] = tp.decls.toList
 
     def members: List[Symbol] = tp.allMembers.map(_.symbol).toList

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

@@ -207,7 +207,7 @@ class GenBCodePipeline(val int: DottyBackendInterface)(implicit val ctx: Context
           if (claszSymbol.companionClass == NoSymbol) {
             mirrorCodeGen.genMirrorClass(claszSymbol, cunit)
           } else {
-            ctx.log(s"No mirror class for module with linked class: ${claszSymbol.fullName}")
+            ctx.log(s"No mirror class for module with linked class: ${claszSymbol.showFullName}")
             null
           }
         } else null

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

@@ -246,15 +246,21 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
     }
   }
 
-  def compileFromStrings(sourceCodes: String*): Unit = {
-    val sourceFiles = sourceCodes.map {sourceCode =>
-      val virtualFile = new VirtualFile(s"compileFromString-${java.util.UUID.randomUUID().toString}")
+  def compileFromStrings(scalaSources: List[String], javaSources: List[String] = Nil): Unit = {
+    def sourceFile(source: String, isJava: Boolean): SourceFile = {
+      val uuid = java.util.UUID.randomUUID().toString
+      val ext = if (isJava) ".java" else ".scala"
+      val virtualFile = new VirtualFile(s"compileFromString-$uuid.$ext")
       val writer = new BufferedWriter(new OutputStreamWriter(virtualFile.output, "UTF-8")) // buffering is still advised by javadoc
-      writer.write(sourceCode)
+      writer.write(source)
       writer.close()
       new SourceFile(virtualFile, Codec.UTF8)
     }
-    compileSources(sourceFiles.toList)
+    val sources =
+      scalaSources.map(sourceFile(_, isJava = false)) ++
+       javaSources.map(sourceFile(_, isJava = true))
+
+    compileSources(sources)
   }
 
   /** Print summary; return # of errors encountered */

compiler/src/dotty/tools/dotc/Run.scala

@@ -787,6 +787,10 @@ object SymDenotations {
      */
     def derivesFrom(base: Symbol)(implicit ctx: Context): Boolean = false
 
+    /** Is this a Scala or Java annotation ? */
+    def isAnnotation(implicit ctx: Context): Boolean =
+      isClass && derivesFrom(defn.AnnotationClass)
+
     /** Is this symbol a class that extends `java.io.Serializable` ? */
     def isSerializable(implicit ctx: Context): Boolean =
       isClass && derivesFrom(defn.JavaSerializableClass)

compiler/src/dotty/tools/dotc/core/SymDenotations.scala

@@ -421,6 +421,7 @@ object Types {
       case tp: ClassInfo => tp.cls
       case tp: SingletonType => NoSymbol
       case tp: TypeProxy => tp.underlying.typeSymbol
+      case  _: JavaArrayType => defn.ArrayClass
       case _ => NoSymbol
     }
 
@@ -448,6 +449,8 @@ object Types {
         else NoSymbol
       case tp: OrType =>
         tp.join.classSymbol
+      case _: JavaArrayType =>
+        defn.ArrayClass
       case _ =>
         NoSymbol
     }

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -123,9 +123,6 @@ object Scala3:
     def isSyntheticWithIdent(using Context): Boolean =
       sym.is(Synthetic) && !sym.isAnonymous && !sym.name.isEmptyNumbered
 
-    def isAnnotation(using Context): Boolean =
-      sym.derivesFrom(defn.AnnotationClass)
-
   // end SymbolOps
 
   object LocalSymbol: