Details
-
Type:
Sub-task
-
Status:
Open
-
Priority:
Major
-
Resolution: Unresolved
-
Affects Version/s: 1.5.4
-
Fix Version/s: None
-
Component/s: None
-
Labels:None
-
Environment:CentOS 5 n Intel with java 1.6.0_03-b05
-
Testcase included:yes
Description
The following script executes two closures. One is statically defined in class Test,
the other is returned by Test.makeClosure(). In each case the delegate of the
Closure is set to be an instance of class Delegate, but in one case a call to
method "foo()" appears to resolve to Test.foo(), while in the second it appears
to resolve to Delegate.foo().
I showed this to Dierk at the G2 conference in Reston, and he asked me to post
it as a bug.
=====================================================================
class Test {
def foo() { "NOT the delegate" }
def makeClosure() {
def closure = {
println foo()
println delegate.foo()
}
}
static staticClosure = { println foo() println delegate.foo() }
}
class Delegate {
def foo() {
"delegate"
}
}
Closure dynamicClosure = new Test().makeClosure()
dynamicClosure.setDelegate(new Delegate())
dynamicClosure.call()
Test.staticClosure.setDelegate(new Delegate())
Test.staticClosure.call()
==================================================================
Expected Output:
delegate
delegate
delegate
delegate
Actual Output:
NOT the delegate
delegate
delegate
delegate
I think this is not an issue and the actual behavior is correct.
This is because the invocation is first tried on owner and then on the delegate. When foo() is invoked by dynamicClosure (returned by Test.makeClosure()), it finds it on the owner (Test.foo()) and invokes it. Since staticClosure is static member of Test, it does not have access to non-static foo() of Test and since it does not find foo() on owner, it next tries the delegate and finds it there and invokes it.
To see the same behavior in both dynamicClosure and staticClosure, if Test.foo() is made static as in:
class Test { static def foo() { "NOT the delegate" } def makeClosure() { def closure = { println foo() println delegate.foo() } } static staticClosure = { println foo() println delegate.foo() } } class Delegate { def foo() { "delegate" } } Closure dynamicClosure = new Test().makeClosure() dynamicClosure.setDelegate(new Delegate()) dynamicClosure.call() Test.staticClosure.setDelegate(new Delegate()) Test.staticClosure.call()Now, the output is:
NOT the delegate // dynamicClosure's foo() goes to owner now since it has access to static Test.foo()
delegate
NOT the delegate // staticClosure's foo() also goes to owner now since it has access to static Test.foo()
delegate
class Test { static def foo() { "NOT the delegate" } def makeClosure() { def closure = { println foo() println delegate.foo() } } static staticClosure = { println foo() println delegate.foo() } } class Delegate { def foo() { "delegate" } } Closure dynamicClosure = new Test().makeClosure() dynamicClosure.setDelegate(new Delegate()) dynamicClosure.call() Test.staticClosure.setDelegate(new Delegate()) Test.staticClosure.call()