LMF cannot instantiate SAM of trait with non-trait superclass

Also, drop AbstractFunction for parent of anonymous subclass of
function type that must have its class spun up at compile time
(rather than at linkage time by LambdaMetaFactory).

This revealed an old problem with typedTemplate, in which
parent types may be normalized at the level of trees,
while this change does not get propagated to the class's info
in time for the constructor to be located when we type check
the primary constructor.

Author: adriaanm

src/compiler/scala/tools/nsc/ast/TreeGen.scala

@@ -310,13 +310,9 @@ abstract class TreeGen extends scala.reflect.internal.TreeGen with TreeDSL {
     newDefDef(methSym, moveToMethod(useMethodParams(fun.body)))(tpt = TypeTree(resTp))
   }
 
-  // TODO: the rewrite to AbstractFunction is superfluous once we compile FunctionN to a SAM type (aka functional interface)
-  def functionClassType(fun: Function): Type =
-    if (isFunctionType(fun.tpe)) abstractFunctionType(fun.vparams.map(_.symbol.tpe), fun.body.tpe.deconst)
-    else fun.tpe
 
   def expandFunction(localTyper: analyzer.Typer)(fun: Function, inConstructorFlag: Long): Tree = {
-    val parents = addObjectParent(addSerializable(functionClassType(fun)))
+    val parents = addSerializable(fun.tpe)
     val anonClass = fun.symbol.owner newAnonymousFunctionClass(fun.pos, inConstructorFlag) addAnnotation SerialVersionUIDAnnotation
 
     // The original owner is used in the backend for the EnclosingMethod attribute. If fun is

src/compiler/scala/tools/nsc/typechecker/Typers.scala

@@ -1747,17 +1747,21 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
             classinfo.parents map (_.instantiateTypeParams(List(tparam), List(AnyRefTpe))),
             classinfo.decls,
             clazz)
-          clazz.setInfo {
-            clazz.info match {
-              case PolyType(tparams, _) => PolyType(tparams, newinfo)
-              case _ => newinfo
-            }
-          }
+          updatePolyClassInfo(clazz, newinfo)
           FinitaryError(tparam)
         }
       }
     }
 
+    private def updatePolyClassInfo(clazz: Symbol, newinfo: ClassInfoType): clazz.type = {
+      clazz.setInfo {
+        clazz.info match {
+          case PolyType(tparams, _) => PolyType(tparams, newinfo)
+          case _ => newinfo
+        }
+      }
+    }
+
     def typedClassDef(cdef: ClassDef): Tree = {
       val clazz = cdef.symbol
       val typedMods = typedModifiers(cdef.mods)
@@ -1866,6 +1870,26 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
       // please FIXME: uncommenting this line breaks everything
       // val templ = treeCopy.Template(templ0, templ0.body, templ0.self, templ0.parents)
       val clazz = context.owner
+
+      val parentTypes = parents1.map(_.tpe)
+
+      // The parents may have been normalized by typedParentTypes.
+      // We must update the info as well, or we won't find the super constructor for our now-first parent class
+      // Consider `class C ; trait T extends C ; trait U extends T`
+      // `U`'s info will start with parent `T`, but `typedParentTypes` will return `List(C, T)` (`== parents1`)
+      // now, the super call in the primary ctor will fail to find `C`'s ctor, since it bases its search on
+      // `U`'s info, not the trees.
+      //
+      // For correctness and performance, we restrict this rewrite to anonymous classes,
+      // as others have their parents in order already (it seems!), and we certainly
+      // don't want to accidentally rewire superclasses for e.g. the primitive value classes.
+      //
+      // TODO: Find an example of a named class needing this rewrite, I tried but couldn't find one.
+      if (clazz.isAnonymousClass && clazz.info.parents != parentTypes) {
+//        println(s"updating parents of $clazz from ${clazz.info.parents} to $parentTypes")
+        updatePolyClassInfo(clazz, ClassInfoType(parentTypes, clazz.info.decls, clazz))
+      }
+
       clazz.annotations.map(_.completeInfo())
       if (templ.symbol == NoSymbol)
         templ setSymbol clazz.newLocalDummy(templ.pos)

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

@@ -581,7 +581,6 @@ trait Definitions extends api.StandardDefinitions {
     /** Creators for TupleN, ProductN, FunctionN. */
     def tupleType(elems: List[Type])                            = TupleClass.specificType(elems)
     def functionType(formals: List[Type], restpe: Type)         = FunctionClass.specificType(formals, restpe)
-    def abstractFunctionType(formals: List[Type], restpe: Type) = AbstractFunctionClass.specificType(formals, restpe)
 
     def wrapArrayMethodName(elemtp: Type): TermName = elemtp.typeSymbol match {
       case ByteClass    => nme.wrapByteArray

src/reflect/scala/reflect/internal/Types.scala

@@ -4553,11 +4553,6 @@ trait Types
     else (ps :+ SerializableTpe).toList
   )
 
-  def addObjectParent(tps: List[Type]) = tps match {
-    case hd :: _ if hd.typeSymbol.isTrait => ObjectTpe :: tps
-    case _ => tps
-  }
-
   /** Adds the @uncheckedBound annotation if the given `tp` has type arguments */
   final def uncheckedBounds(tp: Type): Type = {
     if (tp.typeArgs.isEmpty || UncheckedBoundsClass == NoSymbol) tp // second condition for backwards compatibility with older scala-reflect.jar

test/files/neg/t5761.check

@@ -13,7 +13,7 @@ Unspecified value parameter x.
 t5761.scala:13: error: not found: type Tread
   new Tread("sth") { }.run()
       ^
-t5761.scala:13: error: value run is not a member of AnyRef
+t5761.scala:13: error: value run is not a member of <error>
   new Tread("sth") { }.run()
                        ^
 5 errors found

test/files/run/delambdafy_uncurry_byname_inline.check

@@ -7,7 +7,7 @@ package <empty> {
     };
     def bar(x: () => Int): Int = x.apply();
     def foo(): Int = Foo.this.bar({
-      @SerialVersionUID(value = 0) final <synthetic> class $anonfun extends scala.runtime.AbstractFunction0[Int] with Serializable {
+      @SerialVersionUID(value = 0) final <synthetic> class $anonfun extends Object with () => Int with Serializable {
         def <init>(): <$anon: () => Int> = {
           $anonfun.super.<init>();
           ()

test/files/run/delambdafy_uncurry_inline.check

@@ -7,7 +7,7 @@ package <empty> {
     };
     def bar(): Unit = {
       val f: Int => Int = {
-        @SerialVersionUID(value = 0) final <synthetic> class $anonfun extends scala.runtime.AbstractFunction1[Int,Int] with Serializable {
+        @SerialVersionUID(value = 0) final <synthetic> class $anonfun extends Object with Int => Int with Serializable {
           def <init>(): <$anon: Int => Int> = {
             $anonfun.super.<init>();
             ()

test/files/run/sammy_restrictions_LMF.scala

@@ -8,6 +8,11 @@ trait TImpure { def apply(x: Int): String ; println(1) }
 trait Println { println(1) }
 trait TImpureSuper extends Println { def apply(x: Int): String  }
 
+class C
+trait A extends C
+trait B extends A
+trait TClassParent extends B { def apply(x: Int): String }
+
 object Test extends App {
   final val AnonFunClass = "$anonfun$"
   final val LMFClass = "$$Lambda$" // LambdaMetaFactory names classes like this
@@ -45,4 +50,8 @@ object Test extends App {
 
   notLMF((x => "a"): TImpure)
   notLMF((x => "a"): TImpureSuper)
+
+  val fClassParent: TClassParent = x => "a"
+  notLMF(fClassParent)
+  assert(fClassParent(1) == "a")
 }

test/files/run/t6028.check

@@ -24,9 +24,10 @@ package <empty> {
         (new <$anon: Function0>(T.this, tryyParam, tryyLocal): Function0)
       }
     };
-    @SerialVersionUID(value = 0) final <synthetic> class $anonfun$foo$1 extends scala.runtime.AbstractFunction0$mcI$sp with Serializable {
+    @SerialVersionUID(value = 0) final <synthetic> class $anonfun$foo$1 extends Object with Function0$mcI$sp with Serializable {
       def <init>($outer: T, methodParam$1: Int, methodLocal$1: Int): <$anon: Function0> = {
         $anonfun$foo$1.super.<init>();
+        $anonfun$foo$1.super./*Function0*/$init$();
         ()
       };
       final def apply(): Int = $anonfun$foo$1.this.apply$mcI$sp();
@@ -66,9 +67,10 @@ package <empty> {
       T.this.MethodLocalObject$lzycompute$1(barParam$1, MethodLocalObject$module$1)
     else
       MethodLocalObject$module$1.elem.$asInstanceOf[T#MethodLocalObject$2.type]();
-    @SerialVersionUID(value = 0) final <synthetic> class $anonfun$tryy$1 extends scala.runtime.AbstractFunction0$mcV$sp with Serializable {
+    @SerialVersionUID(value = 0) final <synthetic> class $anonfun$tryy$1 extends Object with Function0$mcV$sp with Serializable {
       def <init>($outer: T, tryyParam$1: Int, tryyLocal$1: runtime.IntRef): <$anon: Function0> = {
         $anonfun$tryy$1.super.<init>();
+        $anonfun$tryy$1.super./*Function0*/$init$();
         ()
       };
       final def apply(): Unit = $anonfun$tryy$1.this.apply$mcV$sp();

test/files/run/t6555.check

@@ -6,7 +6,7 @@ package <empty> {
       ()
     };
     private[this] val f: Int => Int = {
-      @SerialVersionUID(value = 0) final <synthetic> class $anonfun extends scala.runtime.AbstractFunction1$mcII$sp with Serializable {
+      @SerialVersionUID(value = 0) final <synthetic> class $anonfun extends Object with Int => Int with Serializable {
         def <init>(): <$anon: Int => Int> = {
           $anonfun.super.<init>();
           ()