Mercurial > hg > openjdk > jdk6 > langtools
changeset 66:f754eab3d93a
6517779: javax.lang.model.util.Elements.getConstantExpression() doesn't throw any exception
6517907: javax.lang.model.util.Elements.getConstantExpression() with negative byte value fails
6337964: should ignore last comma in annotation array
Reviewed-by: jjg
author | darcy |
---|---|
date | Mon, 28 Sep 2009 18:14:23 -0700 |
parents | 438bf1bab066 |
children | 78efde88dc5a |
files | src/share/classes/com/sun/tools/javac/parser/Parser.java src/share/classes/com/sun/tools/javac/util/Constants.java src/share/classes/com/sun/tools/javac/util/Convert.java test/tools/javac/annotations/pos/TrailingComma.java test/tools/javac/processing/model/util/elements/Foo.java test/tools/javac/processing/model/util/elements/TestGetConstantExpression.java |
diffstat | 6 files changed, 233 insertions(+), 6 deletions(-) [+] |
line wrap: on
line diff
--- a/src/share/classes/com/sun/tools/javac/parser/Parser.java Tue Sep 15 12:24:44 2009 -0700 +++ b/src/share/classes/com/sun/tools/javac/parser/Parser.java Mon Sep 28 18:14:23 2009 -0700 @@ -2024,7 +2024,7 @@ /* AnnotationValue = ConditionalExpression * | Annotation - * | "{" [ AnnotationValue { "," AnnotationValue } ] "}" + * | "{" [ AnnotationValue { "," AnnotationValue } ] [","] "}" */ JCExpression annotationValue() { int pos; @@ -2041,7 +2041,7 @@ buf.append(annotationValue()); while (S.token() == COMMA) { S.nextToken(); - if (S.token() == RPAREN) break; + if (S.token() == RBRACE) break; buf.append(annotationValue()); } }
--- a/src/share/classes/com/sun/tools/javac/util/Constants.java Tue Sep 15 12:24:44 2009 -0700 +++ b/src/share/classes/com/sun/tools/javac/util/Constants.java Mon Sep 28 18:14:23 2009 -0700 @@ -83,16 +83,28 @@ */ public static String format(Object value) { if (value instanceof Byte) return formatByte((Byte) value); + if (value instanceof Short) return formatShort((Short) value); if (value instanceof Long) return formatLong((Long) value); if (value instanceof Float) return formatFloat((Float) value); if (value instanceof Double) return formatDouble((Double) value); if (value instanceof Character) return formatChar((Character) value); if (value instanceof String) return formatString((String) value); - return value + ""; + if (value instanceof Integer || + value instanceof Boolean) return value.toString(); + else + throw new IllegalArgumentException("Argument is not a primitive type or a string; it " + + ((value == null) ? + "is a null value." : + "has class " + + value.getClass().getName()) + "." ); } private static String formatByte(byte b) { - return String.format("0x%02x", b); + return String.format("(byte)0x%02x", b); + } + + private static String formatShort(short s) { + return String.format("(short)%d", s); } private static String formatLong(long lng) {
--- a/src/share/classes/com/sun/tools/javac/util/Convert.java Tue Sep 15 12:24:44 2009 -0700 +++ b/src/share/classes/com/sun/tools/javac/util/Convert.java Mon Sep 28 18:14:23 2009 -0700 @@ -239,9 +239,9 @@ case '\"': return "\\\""; case '\\': return "\\\\"; default: - return (ch > 127 || isPrintableAscii(ch)) + return (isPrintableAscii(ch)) ? String.valueOf(ch) - : String.format("\\%03o", (int) ch); + : String.format("\\u%04x", (int) ch); } }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/tools/javac/annotations/pos/TrailingComma.java Mon Sep 28 18:14:23 2009 -0700 @@ -0,0 +1,43 @@ +/* + * Copyright 2009 Sun Microsystems, Inc. All Rights Reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + */ + +/* + * @test + * @bug 6337964 + * @summary javac incorrectly disallows trailing comma in annotation arrays + * @author darcy + * @compile TrailingComma.java + */ + +import java.lang.annotation.*; + +@interface TestAnnotation { + SuppressWarnings[] value() default {@SuppressWarnings({"",})}; +} + + +@TestAnnotation({@SuppressWarnings(), + @SuppressWarnings({"Beware the ides of March.",}), + @SuppressWarnings({"Look both ways", "Before Crossing",}), }) +public class TrailingComma { +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/tools/javac/processing/model/util/elements/Foo.java Mon Sep 28 18:14:23 2009 -0700 @@ -0,0 +1,29 @@ + +/* + * Copyright 2009 Sun Microsystems, Inc. All Rights Reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + */ + +/** + * Dummy type to compile. + */ +public class Foo { +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/tools/javac/processing/model/util/elements/TestGetConstantExpression.java Mon Sep 28 18:14:23 2009 -0700 @@ -0,0 +1,143 @@ +/* + * Copyright 2009 Sun Microsystems, Inc. All Rights Reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + */ + +/* + * @test + * @bug 6471577 6517779 + * @summary Test Elements.getConstantExpression + * @author Joseph D. Darcy + * @build TestGetConstantExpression + * @compile -processor TestGetConstantExpression Foo.java + */ + +import java.util.Set; +import javax.annotation.processing.*; +import javax.lang.model.SourceVersion; +import static javax.lang.model.SourceVersion.*; +import javax.lang.model.element.*; +import javax.lang.model.util.*; +import static javax.lang.model.util.ElementFilter.*; +import static javax.tools.Diagnostic.Kind.*; +import static javax.tools.StandardLocation.*; +import java.io.*; + +/** + * Test basic workings of Elements.getConstantExpression. + */ +@SupportedAnnotationTypes("*") +public class TestGetConstantExpression extends AbstractProcessor { + private Elements eltUtils; + private Filer filer; + private int round = 1; + + /** + * Check expected behavior on classes and packages. + */ + public boolean process(Set<? extends TypeElement> annotations, + RoundEnvironment roundEnv) { + int errors = 0; + boolean processingOver = roundEnv.processingOver(); + + if (!processingOver && round == 1) { + errors += expectIllegalArgumentException(null); + errors += expectIllegalArgumentException(this); + + // Generate source code with various constant values and + // make sure it compiles. + + try { + PrintWriter pw = new PrintWriter(filer.createSourceFile("ConstantTest").openWriter()); + try { + Boolean[] booleans = {true, false}; + Byte[] bytes = {Byte.MIN_VALUE, -1, 0, 1, Byte.MAX_VALUE}; + Short[] shorts = {Short.MIN_VALUE, -1, 0, 1, Short.MAX_VALUE}; + Integer[] ints = {Integer.MIN_VALUE, -1, 0, 1, Integer.MAX_VALUE}; + Long[] longs = {Long.MIN_VALUE, -1L, 0L,1L, Long.MAX_VALUE}; + Character[] chars = {Character.MIN_VALUE, ' ', '\t', 'a', 'b', 'c', '~', Character.MAX_VALUE}; + Float[] floats = {Float.NaN, Float.NEGATIVE_INFINITY, -1.0f, -0.0f, 0.0f, 1.0f, Float.POSITIVE_INFINITY}; + Double[] doubles = {Double.NaN, Double.NEGATIVE_INFINITY, -1.0, -0.0, 0.0, 1.0, Double.POSITIVE_INFINITY}; + + pw.println("class ConstantTest {"); + pw.println(String.format(" private static boolean[] booleans = {%s};", + printConstants(booleans))); + pw.println(String.format(" private static byte[] bytes = {%s};", + printConstants(bytes))); + pw.println(String.format(" private static short[] shorts = {%s};", + printConstants(shorts))); + pw.println(String.format(" private static int[] ints = {%s};", + printConstants(ints))); + pw.println(String.format(" private static long[] longs = {%s};", + printConstants(longs))); + pw.println(String.format(" private static char[] chars = {%s};", + printConstants(chars))); + pw.println(String.format(" private static float[] floats = {%s};", + printConstants(floats))); + pw.println(String.format(" private static double[] doubles = {%s};", + printConstants(doubles))); + pw.println("}"); + } finally { + pw.close(); + } + } catch(IOException io) { + throw new RuntimeException(io); + } + round++; + } else if (processingOver) { + if (errors > 0) { + throw new RuntimeException(); + } + } + return true; + } + + String printConstants(Object[] constants) { + StringBuilder sb = new StringBuilder(); + + for(Object o : constants) { + sb.append(eltUtils.getConstantExpression(o)); + sb.append(", "); + } + return sb.toString(); + } + + int expectIllegalArgumentException(Object o) { + String s = ""; + try { + s = eltUtils.getConstantExpression(o); + System.err.println("Unexpected string returned: " + s); + return 1; + } catch (IllegalArgumentException iae) { + return 0; + } + } + + public SourceVersion getSupportedSourceVersion() { + return SourceVersion.latest(); + } + + public void init(ProcessingEnvironment processingEnv) { + super.init(processingEnv); + eltUtils = processingEnv.getElementUtils(); + filer = processingEnv.getFiler(); + } +}