changeset 514:fc7132746501

6449781: TypeElement.getQualifiedName for anonymous classes returns null instead of an empty name Reviewed-by: jjg
author darcy
date Wed, 03 Mar 2010 16:05:34 -0800
parents 235135d61974
children 7f5db2e8b423
files src/share/classes/com/sun/tools/javac/jvm/ClassReader.java test/tools/javac/processing/model/element/TestAnonClassNames.java test/tools/javac/processing/model/element/TestAnonSourceNames.java
diffstat 3 files changed, 279 insertions(+), 1 deletions(-) [+]
line wrap: on
line diff
--- a/src/share/classes/com/sun/tools/javac/jvm/ClassReader.java	Tue Mar 02 16:43:29 2010 -0800
+++ b/src/share/classes/com/sun/tools/javac/jvm/ClassReader.java	Wed Mar 03 16:05:34 2010 -0800
@@ -1135,7 +1135,7 @@
         self.name = simpleBinaryName(self.flatname, c.flatname) ;
         self.owner = m != null ? m : c;
         if (self.name.isEmpty())
-            self.fullname = null;
+            self.fullname = names.empty;
         else
             self.fullname = ClassSymbol.formFullName(self.name, self.owner);
 
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/processing/model/element/TestAnonClassNames.java	Wed Mar 03 16:05:34 2010 -0800
@@ -0,0 +1,186 @@
+/*
+ * Copyright 2010 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 6449781
+ * @summary Test that reported names of anonymous classes are non-null.
+ * @author  Joseph D. Darcy
+ * @build TestAnonSourceNames
+ * @compile/fail -processor TestAnonSourceNames TestAnonClassNames.java
+ * @build TestAnonClassNames
+ * @run main TestAnonClassNames
+ */
+
+/*
+ * This test operates in phases to test retrieving the qualified name
+ * of anonymous classes from type elements modeling the anonymous
+ * class.  The type elements are generated using both source files and
+ * class files as the basis of constructing the elements.
+ *
+ * Source files will be tested by the @compile line which runs
+ * TestAnonSourceNames as an annotation processor over this file.
+ * This compile line is expected to fail until 6930507 is fixed.  Once
+ * bug 6930507 is fixed, the "@compile/fail -processor ..." and
+ * following "@build..." steps can be replaced with a single "@compile
+ * -processor ..." directive.
+ *
+ * Class files are tested by the @run command on this type.  This
+ * class gets the names of classes with different nesting kinds,
+ * including anonymous classes, and then invokes the compiler with an
+ * annotation processor having the class files names as inputs.  The
+ * compiler is invoked via the javax.tools mechanism.
+ */
+
+import java.lang.annotation.*;
+import javax.lang.model.element.*;
+import javax.annotation.processing.*;
+import javax.lang.model.SourceVersion;
+import javax.lang.model.element.*;
+import javax.lang.model.util.*;
+import javax.tools.*;
+import java.util.*;
+
+import static java.lang.annotation.RetentionPolicy.*;
+import static javax.lang.model.element.NestingKind.*;
+import static javax.lang.model.util.ElementFilter.*;
+import static javax.tools.Diagnostic.Kind.*;
+import static javax.tools.StandardLocation.*;
+
+@Nesting(TOP_LEVEL)
+public class TestAnonClassNames {
+    @Nesting(MEMBER)
+    static class MemberClass1{}
+
+    @Nesting(MEMBER)
+    class MemberClass2{}
+
+    @Nesting(MEMBER)
+    class Win$$AtVegas { } // Class with funny name.
+
+    public static void main(String... argv) {
+        @Nesting(LOCAL)
+        class LocalClass{};
+
+        Object o =  new @Nesting(ANONYMOUS) Object() { // An anonymous annotated class
+                public String toString() {
+                    return "I have no name!";
+                }
+            };
+
+        Class<?>[] classes = {
+            MemberClass1.class,
+            MemberClass2.class,
+            LocalClass.class,
+            Win$$AtVegas.class,
+            o.getClass(),
+            TestAnonClassNames.class,
+        };
+
+        for(Class<?> clazz : classes) {
+            String name = clazz.getName();
+            System.out.format("%s is %s%n",
+                              clazz.getName(),
+                              clazz.getAnnotation(Nesting.class).value());
+            testClassName(name);
+        }
+    }
+
+    /**
+     * Perform annotation processing on the class file name and verify
+     * the existence of different flavors of class names when the
+     * input classes are modeled as elements.
+     */
+    static void testClassName(String className) {
+        JavaCompiler javaCompiler = ToolProvider.getSystemJavaCompiler();
+        List<String> classNames = new ArrayList<>();
+        classNames.add(className);
+
+        List<String> options = new ArrayList<>();
+        options.add("-proc:only");
+        options.add("-classpath");
+        options.add(System.getProperty("test.classes"));
+
+        JavaCompiler.CompilationTask compileTask =
+            javaCompiler.getTask(null, // Output
+                                 null, // File manager
+                                 null, // Diagnostics
+                                 options,
+                                 classNames,
+                                 null); // Sources
+        List<Processor> processors = new ArrayList<>();
+        processors.add(new ClassNameProber());
+        compileTask.setProcessors(processors);
+        Boolean goodResult = compileTask.call();
+        if (!goodResult) {
+            throw new RuntimeException("Errors found during compile.");
+        }
+    }
+}
+
+@Retention(RUNTIME)
+@interface Nesting {
+    NestingKind value();
+}
+
+/**
+ * Probe at the various kinds of names of a type element.
+ */
+@SupportedAnnotationTypes("*")
+class ClassNameProber extends AbstractProcessor {
+    public ClassNameProber(){super();}
+
+    private boolean classesFound=false;
+
+    public boolean process(Set<? extends TypeElement> annotations,
+                           RoundEnvironment roundEnv) {
+        if (!roundEnv.processingOver()) {
+            for(TypeElement typeElt : typesIn(roundEnv.getRootElements())) {
+                classesFound = true;
+
+                // Verify different names are non-null; an NPE will
+                // result in failed compile status being reported.
+                NestingKind nestingKind = typeElt.getNestingKind();
+                System.out.printf("\tSimple name: ''%s''\tQualified Name: ''%s''\tKind ''%s''\tNesting ''%s''%n",
+                                  typeElt.getSimpleName().toString(),
+                                  typeElt.getQualifiedName().toString(),
+                                  typeElt.getKind().toString(),
+                                  nestingKind.toString());
+
+                if (typeElt.getAnnotation(Nesting.class).value() != nestingKind) {
+                    throw new RuntimeException("Mismatch of expected and reported nesting kind.");
+                }
+            }
+
+        }
+
+        if (!classesFound) {
+            throw new RuntimeException("Error: no classes processed.");
+        }
+        return true;
+    }
+
+    public SourceVersion getSupportedSourceVersion() {
+        return SourceVersion.latest();
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/processing/model/element/TestAnonSourceNames.java	Wed Mar 03 16:05:34 2010 -0800
@@ -0,0 +1,92 @@
+/*
+ * Copyright 2010 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.
+ */
+
+import java.io.*;
+import javax.annotation.processing.*;
+import javax.lang.model.*;
+import javax.lang.model.element.*;
+import javax.lang.model.type.*;
+import javax.lang.model.util.*;
+import java.util.*;
+import com.sun.source.tree.*;
+import com.sun.source.util.*;
+import static javax.tools.Diagnostic.Kind.*;
+
+/**
+ * Using the tree API, retrieve element representations of anonymous
+ * classes and verify their names are as specified.
+ */
+@SupportedAnnotationTypes("*")
+public class TestAnonSourceNames extends AbstractProcessor {
+
+   public boolean process(Set<? extends TypeElement> annotations,
+                          RoundEnvironment roundEnv) {
+       if (!roundEnv.processingOver()) {
+           Trees trees = Trees.instance(processingEnv);
+
+           for(Element rootElement : roundEnv.getRootElements()) {
+               TreePath treePath = trees.getPath(rootElement);
+
+               (new ClassTreeScanner(trees)).
+                   scan(trees.getTree(rootElement),
+                        treePath.getCompilationUnit());
+           }
+       }
+       return true;
+   }
+
+   class ClassTreeScanner extends TreeScanner<Void, CompilationUnitTree> {
+       private Trees trees;
+
+       public ClassTreeScanner(Trees trees) {
+           super();
+           this.trees = trees;
+       }
+       @Override
+       public Void visitClass(ClassTree node, CompilationUnitTree cu) {
+                     Element element = trees.getElement(trees.getPath(cu, node));
+           if (element == null) {
+               processingEnv.getMessager().printMessage(ERROR,
+                                                        "No element retreived for node named ''" +
+                                                        node.getSimpleName() + "''.");
+           } else {
+
+               System.out.println("\nVisiting class ``" + element.getSimpleName() +
+                                  "'' of kind " + element.getKind());
+                         if (element instanceof TypeElement) {
+                   TypeElement typeElement = (TypeElement) element;
+                   String s = typeElement.getQualifiedName().toString();
+                   System.out.println("\tqualified name:" + s);
+               } else {
+                   throw new RuntimeException("TypeElement not gotten from ClassTree.");
+               }
+           }
+           return super.visitClass(node, cu);
+       }
+   }
+
+   @Override
+   public SourceVersion getSupportedSourceVersion() {
+       return SourceVersion.latest();
+   }
+}