LMF cannot run trait's "initializer" (constructor)

Thus, rule out traits that have a constructor (which we use
as a proxy for having potentially side-effecting statements),
and create an anonymous subclass for them at compile time.

Author: adriaanm

src/compiler/scala/tools/nsc/transform/Erasure.scala

@@ -1213,6 +1213,10 @@ abstract class Erasure extends AddInterfaces
       // When we delay sam expansion until after explicit outer & lambda lift, we could decide there whether
       // to expand sam at compile time or use LMF, and this implementation restriction could be lifted.
       sym.isStatic &&
+      // HACK: this is to rule out traits with an effectful initializer.
+      // The constructor only exists if the trait's template has statements.
+      // Sadly, we can't be more precise without access to the tree that defines the SAM's owner.
+      !sym.primaryConstructor.exists &&
       (sym.isInterface || sym.info.decls.forall(mem => mem.isMethod || mem.isType)) // TODO OPT: && {sym setFlag INTERFACE; true})
 
     // we still need to check our ancestors even if the INTERFACE flag is set, as it doesn't take inheritance into account

test/files/run/sammy_restrictions_LMF.check

@@ -0,0 +1,2 @@
+1
+1

test/files/run/sammy_restrictions_LMF.scala

@@ -3,6 +3,11 @@ trait TInt extends T[Int]
 
 trait TWithVal { val x: Any = 1; def apply(x: Int): String }
 
+trait TImpure { def apply(x: Int): String ; println(1) }
+
+trait Println { println(1) }
+trait TImpureSuper extends Println { def apply(x: Int): String  }
+
 object Test extends App {
   final val AnonFunClass = "$anonfun$"
   final val LMFClass = "$$Lambda$" // LambdaMetaFactory names classes like this
@@ -38,5 +43,6 @@ object Test extends App {
   notLMF(fVal)
   assert(fVal.x == 1)
 
-
+  notLMF((x => "a"): TImpure)
+  notLMF((x => "a"): TImpureSuper)
 }