6517779: javax.lang.model.util.Elements.getConstantExpression() doesn't throw any exception

6517907: javax.lang.model.util.Elements.getConstantExpression() with negative byte value fails

Fix various problems with Elements.getConstantExpression()

Reviewed-by: jjg

langtools/src/share/classes/com/sun/tools/javac/util/Constants.java

@@ -83,16 +83,28 @@ public class Constants {
      */
     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) {

langtools/src/share/classes/com/sun/tools/javac/util/Convert.java

@@ -239,9 +239,9 @@ public class Convert {
         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);
         }
     }
 

langtools/test/tools/javac/processing/model/util/elements/Foo.java

@@ -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 {
+}

langtools/test/tools/javac/processing/model/util/elements/TestGetConstantExpression.java

@@ -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();
+    }
+}