diff options
Diffstat (limited to 'test/files/run/sammy_specialization_restriction.scala')
-rw-r--r-- | test/files/run/sammy_specialization_restriction.scala | 34 |
1 files changed, 34 insertions, 0 deletions
diff --git a/test/files/run/sammy_specialization_restriction.scala b/test/files/run/sammy_specialization_restriction.scala new file mode 100644 index 0000000000..4487bb3ad7 --- /dev/null +++ b/test/files/run/sammy_specialization_restriction.scala @@ -0,0 +1,34 @@ +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() +} |