Gentlemen,
some NPE-related problems of today brought me to re-interate one of my older
suggestions.
We have the so-called “safe navigation”[*], which in some cases allows a null
to be propagated out of an expression instead of throwing a NPE. At the moment,
it can be triggered for a particular sub-expression (like property/method-call
and, as of 3, newly also indexing) using a question mark (e.g., “foo?.bar()” or
“foo?[bar]”).
Do please correct me if I am wrong, but far as I know, there still are
expressions which do not allow the “safe mode”, e.g., arithmetic (“a+b” etc).
Furthermore, there are cases when one simply wants a bigger block of code to
contain only null-propagating expressions and never NPE; in such case, using
the question mark syntax is both inconvenient and error-prone (for it is very
easy to forget one of the lot of question marks needed in such a code, and then
get an uncaught unwanted NPE).
For these reasons, I would suggest adding a new annotation, whose name might be
e.g., “ImplicitSafeNavigation”; it would simply force a null-propagation to be
implicitly and automatically used for *all* expressions in the annotated scope,
i.e., NPE would never be thrown for them; for example:
===
@ImplicitSafeNavigation class Foo {
static foo(a,b,c,d,e) {
a.bar+b*c[d]<<e.bax() // just e.g.; would work with *any* expression which
NPEs today
}
}
assert null == Foo.foo(null,null,null,null,null)
===
I wonder whether this enhancement would be possible to implement in some
forthcoming Groovy release? Myself, I believe it would help tremendously.
If feasible, then it is for a further discussion whether in the scope of this
annotation
(a) a safe-navigation syntax (“foo?.bar”) should be ignored as superfluous;
(b) or, whether in this scope it should reverse the behaviour to trigger an NPE
anyway;
(c) or, whether it should be ignored as (a), and aside of that it would be
worth the effort (and technically possible) to add another syntax to force NPE
over a particular sub-expression (e.g., “foo!.bar”).
Thanks and all the best,
OC
[*] The name might not be quite apt, for propagating a null is not inherently
safer than NPEing; those are simply two different approaches, both of which
serve best in different circumstances. A better name would be something like
“null-propagating” or “non-NPE” mode, I guess. Myself, I don't think we should
change the name though, for all are used to it.
