Skip to content

Commit

Permalink
Upate a number of tests for having indyLambda enabled
Browse files Browse the repository at this point in the history 
The delambdafyLambdaClassNames tests was removed, there's nothing to
tests with indyLambda.
  • Loading branch information
@lrytz
lrytz committed Jul 1, 2015
1 parent c5f3764 commit af7165e
Show file tree
Hide file tree
Showing 18 changed files with 84 additions and 322 deletions.
54 changes: 0 additions & 54 deletions test/files/jvm/innerClassAttribute.check
View file

This file was deleted.

37 changes: 13 additions & 24 deletions test/files/jvm/innerClassAttribute/Classes_1.scala
View file
Original file line number Diff line number Diff line change
Expand Up @@ -187,41 +187,30 @@ trait A24 extends A24Base {
}

class SI_9105 {
// the EnclosingMethod attributes depend on the delambdafy strategy (inline vs method)

// outerClass-inline enclMeth-inline outerClass-method enclMeth-method
// outerClass enclMeth
val fun = (s: String) => {
class A // closure null (*) SI_9105 null
def m: Object = { class B; new B } // closure m$1 SI_9105 m$1
val f: Object = { class C; new C } // closure null (*) SI_9105 null
class A // SI_9105 null
def m: Object = { class B; new B } // SI_9105 m$1
val f: Object = { class C; new C } // SI_9105 null
}
def met = (s: String) => {
class D // closure null (*) SI_9105 met
def m: Object = { class E; new E } // closure m$1 SI_9105 m$1
val f: Object = { class F; new F } // closure null (*) SI_9105 met
class D // SI_9105 met
def m: Object = { class E; new E } // SI_9105 m$1
val f: Object = { class F; new F } // SI_9105 met
}

// (*) the originalOwner chain of A (similar for D) is: SI_9105.fun.$anonfun-value.A
// we can get to the anonfun-class (created by uncurry), but not to the apply method.
//
// for C and F, the originalOwner chain is fun.$anonfun-value.f.C. at later phases, the rawowner of f is
// an apply$sp method of the closure class. we could use that as enclosing method, but it would be unsystematic
// (A / D don't have an encl meth either), and also strange to use the $sp, which is a compilation artifact.
// So using `null` looks more like the situation in the source code: C / F are nested classes of the anon-fun, and
// there's no method in between.

def byName(op: => Any) = 0

val bnV = byName {
class G // closure null (*) SI_9105 null
def m: Object = { class H; new H } // closure m$1 SI_9105 m$1
val f: Object = { class I; new I } // closure null (*) SI_9105 null
class G // SI_9105 null
def m: Object = { class H; new H } // SI_9105 m$1
val f: Object = { class I; new I } // SI_9105 null
""
}
def bnM = byName {
class J // closure null (*) SI_9105 bnM
def m: Object = { class K; new K } // closure m$1 SI_9105 m$1
val f: Object = { class L; new L } // closure null (*) SI_9105 bnM
class J // SI_9105 bnM
def m: Object = { class K; new K } // SI_9105 m$1
val f: Object = { class L; new L } // SI_9105 bnM
""
}
}
Expand Down
173 changes: 32 additions & 141 deletions test/files/jvm/innerClassAttribute/Test.scala
View file
Original file line number Diff line number Diff line change
Expand Up @@ -78,9 +78,9 @@ object Test extends BytecodeTest {
println(s"${e.outerClass} / ${e.name} / ${e.descriptor}")
}

def lambdaClass(anonfunName: String, lambdaName: String): String = {
if (classpath.findClass(anonfunName).isDefined) anonfunName else lambdaName
}

val methodHandlesLookup = assertMember(_: InnerClassNode, "java/lang/invoke/MethodHandles", "Lookup", flags = publicStatic | Flags.ACC_FINAL)


def testA1() = {
val List(b1) = innerClassNodes("A1")
Expand Down Expand Up @@ -109,11 +109,7 @@ object Test extends BytecodeTest {
}

def testA4() = {
println("-- A4 --")
printInnerClassNodes("A4")
val fun = lambdaClass("A4$$anonfun$f$1", "A4$lambda$$f$1")
printInnerClassNodes(fun)
printEnclosingMethod(fun)
testInner("A4", methodHandlesLookup)
}

def testA5() = {
Expand Down Expand Up @@ -247,47 +243,11 @@ object Test extends BytecodeTest {
}

def testA19() = {
println("-- A19 --")

printInnerClassNodes("A19")

val fun1 = lambdaClass("A19$$anonfun$1", "A19$lambda$1")
val fun2 = lambdaClass("A19$$anonfun$2", "A19$lambda$2")
val fun3 = lambdaClass("A19$$anonfun$3", "A19$lambda$3")

printInnerClassNodes(fun1)
printInnerClassNodes(fun2)
printInnerClassNodes(fun3)

printEnclosingMethod(fun1)
printEnclosingMethod(fun2)
printEnclosingMethod(fun3)
testInner("A19", methodHandlesLookup)
}

def testA20() = {
println("-- A20 --")

printInnerClassNodes("A20")

val fun1 = lambdaClass("A20$$anonfun$4", "A20$lambda$1")
val fun2 = lambdaClass("A20$$anonfun$4$$anonfun$apply$1", "A20$lambda$$$nestedInAnonfun$5$1")
val fun3 = lambdaClass("A20$$anonfun$4$$anonfun$apply$2", "A20$lambda$$$nestedInAnonfun$5$2")
val fun4 = lambdaClass("A20$$anonfun$4$$anonfun$apply$2$$anonfun$apply$3", "A20$lambda$$$nestedInAnonfun$7$1")

println("fun1: attribute for itself and the two child closures `() => ()` and `() => () => 1`")
printInnerClassNodes(fun1)
println("fun2 () => (): itself and the outer closure")
printInnerClassNodes(fun2)
println("fun3 () => () => (): itself, the outer closure and its child closure")
printInnerClassNodes(fun3)
println("fun4: () => 1: itself and the two outer closures")
printInnerClassNodes(fun4)

println("enclosing: nested closures have outer class defined, but no outer method")
printEnclosingMethod(fun1)
printEnclosingMethod(fun2)
printEnclosingMethod(fun3)
printEnclosingMethod(fun4)
testInner("A20", methodHandlesLookup)
}

def testA21() = {
Expand Down Expand Up @@ -337,70 +297,30 @@ object Test extends BytecodeTest {
}

def testSI_9105() {
val isDelambdafyMethod = classpath.findClass("SI_9105$lambda$1").isDefined
if (isDelambdafyMethod) {
assertEnclosingMethod ("SI_9105$A$3" , "SI_9105", null , null)
assertEnclosingMethod ("SI_9105$B$5" , "SI_9105", "m$1", "()Ljava/lang/Object;")
assertEnclosingMethod ("SI_9105$C$1" , "SI_9105", null , null)
assertEnclosingMethod ("SI_9105$D$1" , "SI_9105", "met", "()Lscala/Function1;")
assertEnclosingMethod ("SI_9105$E$1" , "SI_9105", "m$3", "()Ljava/lang/Object;")
assertEnclosingMethod ("SI_9105$F$1" , "SI_9105", "met", "()Lscala/Function1;")
assertNoEnclosingMethod("SI_9105$lambda$$met$1")
assertNoEnclosingMethod("SI_9105$lambda$1")
assertNoEnclosingMethod("SI_9105")

assertLocal(innerClassNodes("SI_9105$A$3").head, "SI_9105$A$3", "A$3")
assertLocal(innerClassNodes("SI_9105$B$5").head, "SI_9105$B$5", "B$5")
assertLocal(innerClassNodes("SI_9105$C$1").head, "SI_9105$C$1", "C$1")
assertLocal(innerClassNodes("SI_9105$D$1").head, "SI_9105$D$1", "D$1")
assertLocal(innerClassNodes("SI_9105$E$1").head, "SI_9105$E$1", "E$1")
assertLocal(innerClassNodes("SI_9105$F$1").head, "SI_9105$F$1", "F$1")

// by-name
assertEnclosingMethod("SI_9105$G$1", "SI_9105", null , null)
assertEnclosingMethod("SI_9105$H$1", "SI_9105", "m$2", "()Ljava/lang/Object;")
assertEnclosingMethod("SI_9105$I$1", "SI_9105", null , null)
assertEnclosingMethod("SI_9105$J$1", "SI_9105", "bnM", "()I")
assertEnclosingMethod("SI_9105$K$2", "SI_9105", "m$4", "()Ljava/lang/Object;")
assertEnclosingMethod("SI_9105$L$1", "SI_9105", "bnM", "()I")

assert(innerClassNodes("SI_9105$lambda$$met$1").isEmpty)
assert(innerClassNodes("SI_9105$lambda$1").isEmpty)
assert(innerClassNodes("SI_9105").length == 12) // the 12 local classes
} else {
// comment in innerClassAttribute/Classes_1.scala explains the difference between A / C and D / F.
assertEnclosingMethod ("SI_9105$$anonfun$5$A$3" , "SI_9105$$anonfun$5" , null , null)
assertEnclosingMethod ("SI_9105$$anonfun$5$B$5" , "SI_9105$$anonfun$5" , "m$1" , "()Ljava/lang/Object;")
assertEnclosingMethod ("SI_9105$$anonfun$5$C$1" , "SI_9105$$anonfun$5" , null , null)
assertEnclosingMethod ("SI_9105$$anonfun$met$1$D$1", "SI_9105$$anonfun$met$1", null , null)
assertEnclosingMethod ("SI_9105$$anonfun$met$1$E$1", "SI_9105$$anonfun$met$1", "m$3" , "()Ljava/lang/Object;")
assertEnclosingMethod ("SI_9105$$anonfun$met$1$F$1", "SI_9105$$anonfun$met$1", null , null)
assertEnclosingMethod ("SI_9105$$anonfun$5" , "SI_9105" , null , null)
assertEnclosingMethod ("SI_9105$$anonfun$met$1" , "SI_9105" , "met" , "()Lscala/Function1;")
assertNoEnclosingMethod("SI_9105")

assertLocal(ownInnerClassNode("SI_9105$$anonfun$5$A$3"), "SI_9105$$anonfun$5$A$3" , "A$3")
assertLocal(ownInnerClassNode("SI_9105$$anonfun$5$B$5"), "SI_9105$$anonfun$5$B$5" , "B$5")
assertLocal(ownInnerClassNode("SI_9105$$anonfun$5$C$1"), "SI_9105$$anonfun$5$C$1" , "C$1")
assertLocal(ownInnerClassNode("SI_9105$$anonfun$met$1$D$1"), "SI_9105$$anonfun$met$1$D$1", "D$1")
assertLocal(ownInnerClassNode("SI_9105$$anonfun$met$1$E$1"), "SI_9105$$anonfun$met$1$E$1", "E$1")
assertLocal(ownInnerClassNode("SI_9105$$anonfun$met$1$F$1"), "SI_9105$$anonfun$met$1$F$1", "F$1")

// by-name
assertEnclosingMethod("SI_9105$$anonfun$6$G$1", "SI_9105$$anonfun$6", null, null)
assertEnclosingMethod("SI_9105$$anonfun$6$H$1", "SI_9105$$anonfun$6", "m$2", "()Ljava/lang/Object;")
assertEnclosingMethod("SI_9105$$anonfun$6$I$1", "SI_9105$$anonfun$6", null, null)
assertEnclosingMethod("SI_9105$$anonfun$bnM$1$J$1", "SI_9105$$anonfun$bnM$1", null, null)
assertEnclosingMethod("SI_9105$$anonfun$bnM$1$K$2", "SI_9105$$anonfun$bnM$1", "m$4", "()Ljava/lang/Object;")
assertEnclosingMethod("SI_9105$$anonfun$bnM$1$L$1", "SI_9105$$anonfun$bnM$1", null, null)

assertAnonymous(ownInnerClassNode("SI_9105$$anonfun$5"), "SI_9105$$anonfun$5")
assertAnonymous(ownInnerClassNode("SI_9105$$anonfun$met$1"), "SI_9105$$anonfun$met$1")

assert(innerClassNodes("SI_9105$$anonfun$5").length == 4) // itself and three of the local classes
assert(innerClassNodes("SI_9105$$anonfun$met$1").length == 4) // itself and three of the local classes
assert(innerClassNodes("SI_9105").length == 4) // the four anon funs
}
assertEnclosingMethod ("SI_9105$A$3" , "SI_9105", null , null)
assertEnclosingMethod ("SI_9105$B$5" , "SI_9105", "m$1", "()Ljava/lang/Object;")
assertEnclosingMethod ("SI_9105$C$1" , "SI_9105", null , null)
assertEnclosingMethod ("SI_9105$D$1" , "SI_9105", "met", "()Lscala/Function1;")
assertEnclosingMethod ("SI_9105$E$1" , "SI_9105", "m$3", "()Ljava/lang/Object;")
assertEnclosingMethod ("SI_9105$F$1" , "SI_9105", "met", "()Lscala/Function1;")
assertNoEnclosingMethod("SI_9105")

assertLocal(innerClassNodes("SI_9105$A$3").head, "SI_9105$A$3", "A$3")
assertLocal(innerClassNodes("SI_9105$B$5").head, "SI_9105$B$5", "B$5")
assertLocal(innerClassNodes("SI_9105$C$1").head, "SI_9105$C$1", "C$1")
assertLocal(innerClassNodes("SI_9105$D$1").head, "SI_9105$D$1", "D$1")
assertLocal(innerClassNodes("SI_9105$E$1").head, "SI_9105$E$1", "E$1")
assertLocal(innerClassNodes("SI_9105$F$1").head, "SI_9105$F$1", "F$1")

// by-name
assertEnclosingMethod("SI_9105$G$1", "SI_9105", null , null)
assertEnclosingMethod("SI_9105$H$1", "SI_9105", "m$2", "()Ljava/lang/Object;")
assertEnclosingMethod("SI_9105$I$1", "SI_9105", null , null)
assertEnclosingMethod("SI_9105$J$1", "SI_9105", "bnM", "()I")
assertEnclosingMethod("SI_9105$K$2", "SI_9105", "m$4", "()Ljava/lang/Object;")
assertEnclosingMethod("SI_9105$L$1", "SI_9105", "bnM", "()I")

assert(innerClassNodes("SI_9105").length == 13) // the 12 local classes, plus MethodHandles$Lookup
}

def testSI_9124() {
Expand Down Expand Up @@ -530,37 +450,8 @@ object Test extends BytecodeTest {
testInner("NestedInValueClass$A$B", am, b)
testInner("NestedInValueClass$A$C$2", am, c)

val isDelambdafyMethod = classpath.findClass("NestedInValueClass$A$lambda$$f$extension$1").isDefined
if (isDelambdafyMethod) {
List(
"NestedInValueClass$A$lambda$$g$2$1",
"NestedInValueClass$A$lambda$$f$extension$1",
"NestedInValueClass$A$lambda$$$nestedInAnonfun$13$1",
"NestedInValueClass$A$lambda$$NestedInValueClass$A$$$nestedInAnonfun$15$1").foreach(assertNoEnclosingMethod)
testInner("NestedInValueClass$A", a, am)
testInner("NestedInValueClass$A$", a, am, b, c)
testInner("NestedInValueClass$A$lambda$$g$2$1", am)
testInner("NestedInValueClass$A$lambda$$f$extension$1", am)
testInner("NestedInValueClass$A$lambda$$$nestedInAnonfun$13$1", am)
testInner("NestedInValueClass$A$lambda$$NestedInValueClass$A$$$nestedInAnonfun$15$1", am)
} else {
assertEnclosingMethod("NestedInValueClass$A$$anonfun$g$2$1" , "NestedInValueClass$A" , null, null)
assertEnclosingMethod("NestedInValueClass$A$$anonfun$g$2$1$$anonfun$apply$4" , "NestedInValueClass$A$$anonfun$g$2$1" , null, null)
assertEnclosingMethod("NestedInValueClass$A$$anonfun$f$extension$1" , "NestedInValueClass$A" , "f", "()Lscala/collection/immutable/List;")
assertEnclosingMethod("NestedInValueClass$A$$anonfun$f$extension$1$$anonfun$apply$5", "NestedInValueClass$A$$anonfun$f$extension$1", null, null)

val gfun = assertAnonymous(_: I, "NestedInValueClass$A$$anonfun$g$2$1")
val ffun = assertAnonymous(_: I, "NestedInValueClass$A$$anonfun$f$extension$1")
val gfunfun = assertAnonymous(_: I, "NestedInValueClass$A$$anonfun$g$2$1$$anonfun$apply$4")
val ffunfun = assertAnonymous(_: I, "NestedInValueClass$A$$anonfun$f$extension$1$$anonfun$apply$5")

testInner("NestedInValueClass$A", a, am, ffun, gfun)
testInner("NestedInValueClass$A$", a, am, ffun, gfun, b, c)
testInner("NestedInValueClass$A$$anonfun$g$2$1", a, am, gfun, gfunfun)
testInner("NestedInValueClass$A$$anonfun$g$2$1$$anonfun$apply$4", am, gfun, gfunfun)
testInner("NestedInValueClass$A$$anonfun$f$extension$1", a, am, ffun, ffunfun)
testInner("NestedInValueClass$A$$anonfun$f$extension$1$$anonfun$apply$5", am, ffun, ffunfun)
}
testInner("NestedInValueClass$A", a, am)
testInner("NestedInValueClass$A$", a, am, b, c, methodHandlesLookup)
}

def show(): Unit = {
Expand Down

0 comments on commit af7165e

Please sign in to comment.