Each non-static inner class instance has a reference to the outer class instance from which it was created.
As long as you keep a reference to such inner class instance, its creator object, the outer class instance, will be kept in memory too. In some cases this is undesirable, thus causes the outer class instance leak. Such cases are hard to find manually, without using this inspection.
Consider example:
interface Foo {}
class FooBuilder {
// inner non-static class implementing Foo, has reference to FooBuilder
class FooImpl implements Foo {}
Foo createFoo() {
return new FooImpl();
}
}
As long as you keep references to Foo instances created with FooBuilder, you'll keep the builder objects in memory too. If the builder's purpose is solely to create a Foo and then be thrown away, this creates a leak.
Of course, there are legitimate cases when such retention is desired. The inspection mechanically shows all cases, and it's up to the analyst to decide on each particular reported case.