Re: Annotation syntax in the JLS?
On Sun, 12 Apr 2009, Arne Vajh?j wrote:
Tom Anderson wrote:
Stupid question - where's the definition of the syntax, at the lexical
level, of annotations in the JLS? I mean the application of annotations,
specifically to classes - the rules that make this:
@Foo
public class Bar {}
legal.
There's nothing in chapter 3 about them, and nothing in the relevant bits
of chapter 9 about syntax.
I came across something weird the other day, where the Eclipse and Sun
compilers seem to differ over whether a comma is permitted after the last
item in a literal array of classes that's used as an annotation value.
Normally, java permits the bonus comma after the last item:
int[] a = new int[] {1, 2, 3,}; // legal
But javac seemed to be rejecting this:
import org.junit.Suite;
@Suite.SuiteClasses({
Foo.class,
Bar.class, // illegal!
})
public class MySuite {}
I'm a bit puzzled over the lexical status of the structure comprising the
curly brackets and their contents (the comma, and why a "new Class[]" isn't
needed), and would like to see what the letter of the law is, but can't
find it.
Section 9.7 has:
NormalAnnotation:
@ TypeName ( ElementValuePairsopt )
ElementValuePairs:
ElementValuePair
ElementValuePairs , ElementValuePair
ElementValuePair:
Identifier = ElementValue
ElementValue:
ConditionalExpression
Annotation
ElementValueArrayInitializer
ElementValueArrayInitializer:
{ ElementValuesopt ,opt }
ElementValues:
ElementValue
ElementValues , ElementValue
Aha, yes, thank you! Not sure how i missed that.
Grammar is not be strong side but I assume you code is a single
ElementValuePair where Identifier is default and ElementValue is an
ElementValueArrayInitializer.
Indeed. And the production for ElementValueArrayInitializer does admit a
trailing comma: the production for ElementValues doesn't, but
ElementValueArrayInitializer has that ,opt in it.
Or at least i think it does. The typesetting in the HTML there is a bit
wacky - the comma in question is set as part of the opt subscript, rather
than at the same level as the ElementValues, but i *think* that's a
mistake; chapter 2, which defines the grammar notation, doesn't give any
meaning to a comma-separated double opt subscript, so i assume it can't
actually be that.
Anyway, it's striking that the spec defines an array initializer syntax
just for annotations, rather than reusing the one defined earlier for
actual arrays. I wonder why? I notice that the way it's done lets
annotation arrays include other annotations, which normal arrays, i think,
don't. Like this:
@Foo({@Bar, @Baz, @Qux})
I don't know what that means, though.
tom
--
Coldplay is the kind of music computers will make when they get smart
enough to start making fun of humans -- Lower Marsh Tit