Fix IncompatibleClassChangeError under Java 9

The itf flag of `visitMethodInsn` and `Handle` in ASM needs to be true
when the method is defined in an interface. Java 8 ignores this but Java
9 fails at runtime with:
java.lang.IncompatibleClassChangeError: Method ... must beInterfaceMethodref constant

This commit is inspired by similar changes in scalac, in particular see
7d51b3f by Jason Zaugg
(from scala#5251) and
e619b03 by Lukas Rytz
(from scala#5293). This issue was also
discussed in scala#5452 (which does not
matter for Dotty since we do not run the backend optimizer).

Author: smarter

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

@@ -691,15 +691,15 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
           val nativeKind = tpeTK(expr)
           genLoad(expr, nativeKind)
           val MethodNameAndType(mname, methodType) = asmBoxTo(nativeKind)
-          bc.invokestatic(BoxesRunTime.internalName, mname, methodType.descriptor)
+          bc.invokestatic(BoxesRunTime.internalName, mname, methodType.descriptor, itf = false)
           generatedType = boxResultType(fun.symbol) // was toTypeKind(fun.symbol.tpe.resultType)
 
         case Apply(fun, List(expr)) if isUnbox(fun.symbol) =>
           genLoad(expr)
           val boxType = unboxResultType(fun.symbol) // was toTypeKind(fun.symbol.owner.linkedClassOfClass.tpe)
           generatedType = boxType
           val MethodNameAndType(mname, methodType) = asmUnboxTo(boxType)
-          bc.invokestatic(BoxesRunTime.internalName, mname, methodType.descriptor)
+          bc.invokestatic(BoxesRunTime.internalName, mname, methodType.descriptor, itf = false)
 
         case app @ Apply(fun, args) =>
           val sym = fun.symbol
@@ -1142,15 +1142,16 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
         }
       }
 
-      if (style.isStatic)                 { bc.invokestatic   (jowner, jname, mdescr) }
-      else if (style.isSpecial)           { bc.invokespecial  (jowner, jname, mdescr) }
+      val isInterface = receiver.isEmittedInterface
+      if (style.isStatic)                 { bc.invokestatic   (jowner, jname, mdescr, itf = isInterface) }
+      else if (style.isSpecial)           { bc.invokespecial  (jowner, jname, mdescr, itf = isInterface) }
       else if (style.isVirtual) {
         if (needsInterfaceCall(receiver)) { bc.invokeinterface(jowner, jname, mdescr) }
         else                              { bc.invokevirtual  (jowner, jname, mdescr) }
       }
       else {
         assert(style.isSuper, s"An unknown InvokeStyle: $style")
-        bc.invokespecial(jowner, jname, mdescr)
+        bc.invokespecial(jowner, jname, mdescr, itf = isInterface)
         initModule()
       }
 
@@ -1397,17 +1398,19 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
     def genInvokeDynamicLambda(ctor: Symbol, lambdaTarget: Symbol, environmentSize: Int, functionalInterface: Symbol): BType = {
       debuglog(s"Using invokedynamic rather than `new ${ctor.owner}`")
       val generatedType = classBTypeFromSymbol(functionalInterface)
+      val isInterface = lambdaTarget.owner.isEmittedInterface
       val invokeStyle =
         if (lambdaTarget.isStaticMember) asm.Opcodes.H_INVOKESTATIC
         else if (lambdaTarget.isPrivate || lambdaTarget.isClassConstructor) asm.Opcodes.H_INVOKESPECIAL
-        else if (lambdaTarget.owner.isInterface) asm.Opcodes.H_INVOKEINTERFACE
+        else if (isInterface) asm.Opcodes.H_INVOKEINTERFACE
         else asm.Opcodes.H_INVOKEVIRTUAL
 
       val targetHandle =
         new asm.Handle(invokeStyle,
           classBTypeFromSymbol(lambdaTarget.owner).internalName,
           lambdaTarget.name.mangledString,
-          asmMethodType(lambdaTarget).descriptor)
+          asmMethodType(lambdaTarget).descriptor,
+          /* itf = */ isInterface)
 
       val (a,b) = lambdaTarget.info.paramTypes.splitAt(environmentSize)
       var (capturedParamsTypes, lambdaParamTypes) = if(int.doLabmdasFollowJVMMetafactoryOrder) (a,b) else (b,a)
@@ -1437,6 +1440,7 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
   val lambdaMetaFactoryBootstrapHandle =
     new asm.Handle(asm.Opcodes.H_INVOKESTATIC,
       int.LambdaMetaFactory.javaBinaryName, int.MetafactoryName,
-      "(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;")
+      "(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;",
+      /* itf = */  int.LambdaMetaFactory.isEmittedInterface)
 
 }

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

@@ -215,7 +215,8 @@ trait BCodeIdiomatic {
       invokespecial(
         StringBuilderClassName,
         INSTANCE_CONSTRUCTOR_NAME,
-        "()V"
+        "()V",
+        itf = false
       )
     }
 
@@ -393,12 +394,12 @@ trait BCodeIdiomatic {
     final def rem(tk: BType): Unit = { emitPrimitive(JCodeMethodN.remOpcodes, tk) } // can-multi-thread
 
     // can-multi-thread
-    final def invokespecial(owner: String, name: String, desc: String): Unit = {
-      jmethod.visitMethodInsn(Opcodes.INVOKESPECIAL, owner, name, desc, false)
+    final def invokespecial(owner: String, name: String, desc: String, itf: Boolean): Unit = {
+      jmethod.visitMethodInsn(Opcodes.INVOKESPECIAL, owner, name, desc, itf)
     }
     // can-multi-thread
-    final def invokestatic(owner: String, name: String, desc: String): Unit = {
-      jmethod.visitMethodInsn(Opcodes.INVOKESTATIC, owner, name, desc, false)
+    final def invokestatic(owner: String, name: String, desc: String, itf: Boolean): Unit = {
+      jmethod.visitMethodInsn(Opcodes.INVOKESTATIC, owner, name, desc, itf)
     }
     // can-multi-thread
     final def invokeinterface(owner: String, name: String, desc: String): Unit = {
@@ -409,10 +410,6 @@ trait BCodeIdiomatic {
       jmethod.visitMethodInsn(Opcodes.INVOKEVIRTUAL, owner, name, desc, false)
     }
 
-    final def invokedynamic(owner: String, name: String, desc: String): Unit = {
-      jmethod.visitMethodInsn(Opcodes.INVOKEDYNAMIC, owner, name, desc)
-     }
-
     // can-multi-thread
     final def goTo(label: asm.Label): Unit = { jmethod.visitJumpInsn(Opcodes.GOTO, label) }
     // can-multi-thread

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

@@ -440,6 +440,14 @@ abstract class BackendInterface extends BackendInterfaceDefinitions {
     def tpe: Type // todo whats the differentce between tpe and info?
     def thisType: Type
 
+    /** 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.
+     */
+    final def isEmittedInterface: Boolean = isInterface ||
+      isJavaDefined && isModuleClass && companionClass.isInterface
+
     // tests
     def isClass: Boolean
     def isType: Boolean