I know you guys and Keith Lea talked about non-annotated elements a little bit. I just thought I'd give a user's point of view. Let's say I have the following code public void doSomething (@NotNull Object p1) { // Hey I love annotations! I can guarantee that if I have no warnings, p1 is never null. // Great! int hashCode = p1.hashCode(); } Now I have an external library with a method /**

• @return maybe null */ public Object getMaybeNull () { return null; }

And my code is doSomething (getMaybeNull()); Idea won't warn me, because the method isn't annotated. But I'll get a NPE in my code that I thought was safe. I then have two options, write @Nullable Object ret = getMaybeNull (); doSomething (ret); which is kind of ugly and wasteful. Or I do public void doSomething (@NotNull Object p1) { // Hmm, not so sure about these annotations now if (p1 == null) throw new IllegalArgumentException ("p1 may not be null"); int hashCode = p1.hashCode(); } which of course is ugly and will be flagged by Idea. It seems to me that there are certain circumstances where we should suppose that unannotated elements are @Nullable. Presumably you have played with this and found that it gives far too much yellow. But it seems to me that the assignment of an unknown element type to an element which has been declared to be @NotNull should be flagged, or we should have the option to flag.