diff options
author | Iulian Dragos <jaguarul@gmail.com> | 2012-07-17 10:50:59 +0200 |
---|---|---|
committer | Iulian Dragos <jaguarul@gmail.com> | 2012-07-18 15:01:25 +0200 |
commit | 01be1b1c201d6908522d7254075fd1cdf633809a (patch) | |
tree | 322b4f62436a5483dcfa9f9d04afdff2ba5ce2cb /test/files/run | |
parent | ff954063ae75376d284bb09302ea3ccba8cdc268 (diff) | |
download | scala-01be1b1c201d6908522d7254075fd1cdf633809a.tar.gz scala-01be1b1c201d6908522d7254075fd1cdf633809a.tar.bz2 scala-01be1b1c201d6908522d7254075fd1cdf633809a.zip |
Fixed SI-6092. Fixed leaky annotations, and relaxed the conditions under which a try-catch is lifted
out to an inner method.
Less known fact: lazy values null-out their dependent values is their accessed only from
their initializer. The analysis is not context-dependent (meaning the owner where a reference
happens needs to be exactly that lazy value).
* Removed no-op code around positions in `LazyAnnotationInfo`
* Don't lift expressions that have no `catch` clause
The two changes combined fix a memory leak that's been plaguing the IDE: an annotation
(even when forced) would hang on to a namer, through the outer field of its call-by-name
parameter.
The test for the memory leak is in the IDE project (couldn't find a simple way to reproduce it outside
the IDE), but there's a test checking that the field is null after initialization.
Diffstat (limited to 'test/files/run')
-rw-r--r-- | test/files/run/nullable-lazyvals.check | 3 | ||||
-rw-r--r-- | test/files/run/nullable-lazyvals.scala | 36 |
2 files changed, 39 insertions, 0 deletions
diff --git a/test/files/run/nullable-lazyvals.check b/test/files/run/nullable-lazyvals.check new file mode 100644 index 0000000000..4db5783257 --- /dev/null +++ b/test/files/run/nullable-lazyvals.check @@ -0,0 +1,3 @@ + +param1: null +param2: null diff --git a/test/files/run/nullable-lazyvals.scala b/test/files/run/nullable-lazyvals.scala new file mode 100644 index 0000000000..c201e74e75 --- /dev/null +++ b/test/files/run/nullable-lazyvals.scala @@ -0,0 +1,36 @@ + +/** Test that call-by-name parameters are set to null if + * they are used only to initialize a lazy value, after the + * value has been initialized. + */ + +class Foo(param1: => Object, param2: => String) { + lazy val field1 = param1 + lazy val field2 = try param2 finally println("") +} + +object Test extends App { + val foo = new Foo(new Object, "abc") + + foo.field1 + foo.field2 + + for (f <- foo.getClass.getDeclaredFields) { + f.setAccessible(true) + if (f.getName.startsWith("param")) { + println("%s: %s".format(f.getName, f.get(foo))) + } + } + + // test that try-finally does not generated a liftedTry + // helper. This would already fail the first part of the test, + // but this check will help diganose it (if the single access to a + // private field does not happen directly in the lazy val, it won't + // be nulled). + for (f <- foo.getClass.getDeclaredMethods) { + f.setAccessible(true) + if (f.getName.startsWith("lifted")) { + println("not expected: %s".format(f)) + } + } +} |