2 files changed, 42 insertions, 34 deletions
diff --git a/test/files/run/sammy_restrictions_LMF.scala b/test/files/run/sammy_restrictions_LMF.scala
new file mode 100644
index 0000000000..40bb234a72
--- /dev/null
+++ b/test/files/run/sammy_restrictions_LMF.scala
@@ -0,0 +1,42 @@
+trait T[@specialized A] { def apply(a: A): A }
+trait TInt extends T[Int]
+
+trait TWithVal { val x: Any = 1; def apply(x: Int): String }
+
+object Test extends App {
+  final val AnonFunClass = "$anonfun$"
+  final val LMFClass = "$$Lambda$" // LambdaMetaFactory names classes like this
+
+  private def LMF(f: Any): Unit = {
+    val className = f.getClass.toString
+    assert(!(className contains AnonFunClass), className)
+    assert((className contains LMFClass), className)
+  }
+
+  private def notLMF(f: Any): Unit = {
+    val className = f.getClass.toString
+    assert((className contains AnonFunClass), className)
+    assert(!(className contains LMFClass), className)
+  }
+
+  // Check that we expand the SAM of a type that is specialized.
+  // This is an implementation restriction -- the current specialization scheme is not
+  // amenable to using LambdaMetaFactory to spin up subclasses.
+  // Since the generic method is abstract, and the specialized ones are concrete,
+  // specialization is rendered moot because we cannot implement the specialized method
+  // with the lambda using LMF.
+
+  // not LMF if specialized at this type
+  notLMF((x => x): T[Int])
+  // not LMF if specialized at this type (via subclass)
+  notLMF((x => x): TInt)
+  // LMF ok if not specialized at this type
+  LMF((x => x): T[String])
+
+  // traits with a val member also cannot be instantiated by LMF
+  val fVal: TWithVal = (x => "a")
+  notLMF(fVal)
+  assert(fVal.x == 1)
+
+
+}
diff --git a/test/files/run/sammy_specialization_restriction.scala b/test/files/run/sammy_specialization_restriction.scala
deleted file mode 100644
index 4487bb3ad7..0000000000
--- a/test/files/run/sammy_specialization_restriction.scala
+++ /dev/null
@@ -1,34 +0,0 @@
-trait T[@specialized A] { def apply(a: A): A }
-trait TInt extends T[Int]
-
-// Check that we expand the SAM of a type that is specialized.
-// This is an implementation restriction -- the current specialization scheme is not
-// amenable to using LambdaMetaFactory to spin up subclasses.
-// Since the generic method is abstract, and the specialized ones are concrete,
-// specialization is rendered moot because we cannot implement the specialized method
-// with the lambda using LMF.
-object Test extends App {
-  final val AnonFunClass = "$anonfun$"
-  final val LMFClass = "$$Lambda$" // LambdaMetaFactory names classes like this
-
-  def specializedSamPrecludesLMF() = {
-    val className = ((x => x): T[Int]).getClass.toString
-    assert((className contains AnonFunClass), className)
-    assert(!(className contains LMFClass), className)
-  }
-
-  def specializedSamSubclassPrecludesLMF() = {
-    val className = ((x => x): TInt).getClass.toString
-    assert((className contains AnonFunClass), className)
-    assert(!(className contains LMFClass), className)
-  }
-
-  def nonSpecializedSamUsesLMF() = {
-    val className = ((x => x): T[String]).getClass.toString
-    assert(!(className contains AnonFunClass), className)
-    assert(className contains LMFClass, className)
-  }
-
-  specializedSamPrecludesLMF()
-  nonSpecializedSamUsesLMF()
-}