| /* | |
| * Copyright (c) 2023, Oracle and/or its affiliates. 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA | |
| * or visit www.oracle.com if you need additional information or have any | |
| * questions. | |
| */ | |
| /* | |
| * @test | |
| * @bug 8306112 8309568 | |
| * @summary Test basic processing of implicitly declared classes. | |
| * @library /tools/javac/lib | |
| * @modules java.compiler | |
| * jdk.compiler | |
| * @build JavacTestingAbstractProcessor TestImplicitClass | |
| * @compile -processor TestImplicitClass --enable-preview --release ${jdk.version} Anonymous.java | |
| * @clean Nameless.java | |
| * @compile/process -processor TestImplicitClass -proc:only --enable-preview --release ${jdk.version} -Xprefer:newer -AclassOnly Anonymous Nameless | |
| */ | |
| // The first @compile line processes Anonymous.java and a | |
| // Nameless.java class generated using the Filer. Both of those implicitly | |
| // declared classes are then compiled down to class files. The second | |
| // @compile line, as directed by -Xprefer:newer, builds and checks the | |
| // language model objects constructed from those class files, ignoring | |
| // any source files for those types. | |
| import java.lang.annotation.*; | |
| import java.io.Writer; | |
| import java.util.List; | |
| import java.util.Set; | |
| import javax.annotation.processing.*; | |
| import javax.lang.model.element.*; | |
| import javax.lang.model.util.Elements; | |
| import static javax.lang.model.util.ElementFilter.*; | |
| import javax.tools.JavaFileObject; | |
| /** | |
| * Test annotation processing representation of implicitly declared classes | |
| * constructed from either a source file or a class file. | |
| */ | |
| @SuppressWarnings("preview") | |
| @SupportedOptions("classOnly") | |
| public class TestImplicitClass extends JavacTestingAbstractProcessor { | |
| private static int round = 0; | |
| private static int checkedClassesCount = 0; | |
| private static boolean classOnly = false; | |
| public boolean process(Set<? extends TypeElement> annotations, | |
| RoundEnvironment roundEnv) { | |
| if (round == 0) { | |
| classOnly = options.containsKey("classOnly"); | |
| checkRoots(roundEnv); // Check any files from the comamnd line | |
| // Don't generate any files if testing pre-existing class files | |
| if (!classOnly) { | |
| generateImplicitClass(); | |
| } | |
| } else { | |
| if (!roundEnv.processingOver()) { // Test generated file(s) | |
| checkRoots(roundEnv); | |
| } else { // Should have checked at least one class before processing is over | |
| if (checkedClassesCount == 0) { | |
| messager.printError("No implicitly declared classes checked."); | |
| } | |
| } | |
| } | |
| round++; | |
| return true; | |
| } | |
| private void checkRoots(RoundEnvironment roundEnv) { | |
| int checks = 0; | |
| for (TypeElement type : typesIn(roundEnv.getRootElements())) { | |
| checks++; | |
| checkUnnamedClassProperties(type); | |
| } | |
| if (checks == 0) { | |
| messager.printError("No checking done of any candidate implicitly declared classes."); | |
| } | |
| } | |
| private void generateImplicitClass() { | |
| try { | |
| String unnamedSource = """ | |
| void main() { | |
| System.out.println("Nameless, but not voiceless."); | |
| } | |
| """; | |
| JavaFileObject outputFile = processingEnv.getFiler().createSourceFile("Nameless"); | |
| try(Writer w = outputFile.openWriter()) { | |
| w.append(unnamedSource); | |
| } | |
| } catch (java.io.IOException ioe) { | |
| throw new RuntimeException(ioe); | |
| } | |
| } | |
| /* | |
| * From JEP 463 JLS changes: | |
| * | |
| * "An implicitly declared class compilation unit implicitly declares a class that | |
| * satisfies the following properties: | |
| * It is always a top level class. | |
| * It is never abstract (8.1.1.1). | |
| * It is always final (8.1.1.2). | |
| * It is always a member of an unnamed package (7.4.2) and has package access. | |
| * Its direct superclass type is always Object (8.1.4). | |
| * It never has any direct superinterface types (8.1.5). | |
| * | |
| * The body of the class contains every ClassMemberDeclaration | |
| * from the implicitly declared class compilation unit. It is not possible for | |
| * an implicitly declared class compilation unit to declare an instance | |
| * initializer, static initializer, or constructor. | |
| * | |
| * It has an implicitly declared default constructor (8.8.9). | |
| * All members of this class, including any implicitly declared | |
| * members, are subject to the usual rules for member declarations | |
| * in a class. | |
| * | |
| * It is a compile-time error if this class does not declare a candidate main method (12.1.4). | |
| */ | |
| void checkUnnamedClassProperties(TypeElement implicitClass) { | |
| checkedClassesCount++; | |
| Name expectedName = implicitClass.getSimpleName(); | |
| System.out.println("Checking " + expectedName); | |
| if (implicitClass.getNestingKind() != NestingKind.TOP_LEVEL) { | |
| messager.printError("Implicitly declared class is not top-level.", implicitClass); | |
| } | |
| if (!implicitClass.getQualifiedName().equals(expectedName)) { | |
| messager.printError("Implicitly declared class qualified name does not match simple name.", implicitClass); | |
| } | |
| Name binaryName = elements.getBinaryName(implicitClass); | |
| if (!expectedName.equals(binaryName)) { | |
| messager.printError("Implicitly declared class has unexpected binary name" + binaryName + ".", implicitClass); | |
| } | |
| if (implicitClass.getModifiers().contains(Modifier.ABSTRACT)) { | |
| messager.printError("Implicitly declared class is abstract.", implicitClass); | |
| } | |
| if (!implicitClass.getModifiers().contains(Modifier.FINAL)) { | |
| messager.printError("Implicitly declared class is _not_ final.", implicitClass); | |
| } | |
| if (!elements.getPackageOf(implicitClass).isUnnamed()) { | |
| messager.printError("Implicitly declared class is _not_ in an unnamed package.", implicitClass); | |
| } | |
| if (implicitClass.getModifiers().contains(Modifier.PUBLIC) || | |
| implicitClass.getModifiers().contains(Modifier.PRIVATE) || | |
| implicitClass.getModifiers().contains(Modifier.PROTECTED)) { | |
| messager.printError("Implicitly declared class does _not_ have package access.", implicitClass); | |
| } | |
| if ( !types.isSameType(implicitClass.getSuperclass(), | |
| elements.getTypeElement("java.lang.Object").asType())) { | |
| messager.printError("Implicitly declared class does _not_ have java.lang.Object as a superclass.", implicitClass); | |
| } | |
| if (!implicitClass.getInterfaces().isEmpty()) { | |
| messager.printError("Implicitly declared class has superinterfaces.", implicitClass); | |
| } | |
| List<ExecutableElement> ctors = constructorsIn(implicitClass.getEnclosedElements()); | |
| if (ctors.size() != 1 ) { | |
| messager.printError("Did not find exactly one constructor", implicitClass); | |
| } | |
| if (!classOnly) { | |
| // Mandated-ness of default constructors not preserved in class files | |
| ExecutableElement ctor = ctors.getFirst(); | |
| if (elements.getOrigin(ctor) != Elements.Origin.MANDATED) { | |
| messager.printError("Constructor was not marked as mandated", ctor); | |
| } | |
| } | |
| List<ExecutableElement> methods = methodsIn(implicitClass.getEnclosedElements()); | |
| // Just look for a method named "main"; don't check the other details. | |
| boolean mainFound = false; | |
| Name mainName = elements.getName("main"); | |
| for (var method : methods) { | |
| if (method.getSimpleName().equals(mainName)) { | |
| mainFound = true; | |
| break; | |
| } | |
| } | |
| if (!mainFound) { | |
| messager.printError("No main method found", implicitClass); | |
| } | |
| } | |
| } |