jdk-24/test/langtools/tools/javac/processing/model/util/elements/TestGetEnumConstantBody.java

/*
 * 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 8312418
 * @summary Test Elements.getEnumConstantBody
 * @library /tools/javac/lib
 * @build   JavacTestingAbstractProcessor TestGetEnumConstantBody
 * @compile -processor TestGetEnumConstantBody -XDshould.stop-at=FLOW TestGetEnumConstantBody.java
 */

import java.io.IOException;
import java.io.Writer;
import java.util.*;
import java.util.function.*;
import javax.annotation.processing.*;
import javax.lang.model.element.*;
import javax.lang.model.util.*;
import javax.lang.model.type.*;

/**
 * Test basic workings of Elements.getEnumConstantBody
 */
public class TestGetEnumConstantBody extends JavacTestingAbstractProcessor {
    private Elements vacuousElements = new VacuousElements();
    private Set<Element> allElements = new HashSet<>();
    private int round;

    public boolean process(Set<? extends TypeElement> annotations,
                           RoundEnvironment roundEnv) {

        allElements.addAll(roundEnv.getRootElements());

        // In the innermost loop, examine the fields defined by the the nested classes
        for (TypeElement typeRoot : ElementFilter.typesIn(allElements) ) {
            if (typeRoot.getQualifiedName().contentEquals("Gen")) {
                continue;
            }

            boolean elementSeen = false;

            for (TypeElement typeElt : ElementFilter.typesIn(typeRoot.getEnclosedElements()) ) {
                System.out.println("Testing type " + typeElt);

                for (VariableElement field : ElementFilter.fieldsIn(typeElt.getEnclosedElements()) ) {
                    elementSeen = true;
                    System.out.println(field);
                    switch (field.getKind()) {
                    case FIELD         -> expectIAE(field);
                    case ENUM_CONSTANT -> testEnumConstant(field, typeElt);
                    default            -> throw new RuntimeException("Unexpected field kind seen");
                    }
                }
            }

            if (!elementSeen) {
                throw new RuntimeException("No elements seen.");
            }
        }
        switch (round++) {
            case 0:
                try (Writer w = processingEnv.getFiler().createSourceFile("Cleaned").openWriter()) {
                    w.write("""
                            class Enclosing {
                                enum Cleaned {
                                    @TestGetEnumConstantBody.ExpectedBinaryName("Enclosing$Cleaned$2")
                                    A(new Object() {}) {
                                        void test(Gen g) {
                                            g.run();
                                        }
                                    },
                                    B,
                                    @TestGetEnumConstantBody.ExpectedBinaryName("Enclosing$Cleaned$4")
                                    C(new Object() {}) {
                                    };

                                    private Cleaned() {}

                                    private Cleaned(Object o) {}
                                }
                            }
                            """);
                } catch (IOException ex) {
                    throw new RuntimeException(ex);
                }
                break;
            case 1:
                try (Writer w = processingEnv.getFiler().createSourceFile("Gen").openWriter()) {
                    w.write("""
                            public class Gen {
                                public void run() {}
                            }
                            """);
                } catch (IOException ex) {
                    throw new RuntimeException(ex);
                }
                break;
        }
        return true;
    }

    private String computeExpectedBinaryName(VariableElement e) {
        ExpectedBinaryName ebn = e.getAnnotation(ExpectedBinaryName.class);
        return (ebn == null) ? null : ebn.value();
    }

    private void expectIAE(VariableElement variable) {
        expectException0(() ->  elements.getEnumConstantBody(variable),
                         "Expected exception not thrown");

        expectException0(() ->  vacuousElements.getEnumConstantBody(variable),
                         "Expected vacuous exception not thrown");
    }

    private void expectException0(Supplier<TypeElement> supplier, String message) {
        try {
            var typeElement = supplier.get();
            messager.printError(message, typeElement);
        } catch (IllegalArgumentException iae) {
            ; // Expected
        }
    }

    void expectUOE(VariableElement field) {
        try {
            var result = vacuousElements.getEnumConstantBody(field);
            messager.printError("Unexpected non-exceptional result returned", field);

        } catch(UnsupportedOperationException uoe) {
            ; // Expected
        }
    }

    private void testEnumConstant(VariableElement field,
                                  TypeElement enclosingClass) {
        String expectedBinaryName = computeExpectedBinaryName(field);
        boolean expectEnumConstantBody = expectedBinaryName != null;

        System.out.println("\tTesting enum constant " + field + " expected " + expectEnumConstantBody);
        expectUOE(field);

        TypeElement enumConstantBody = elements.getEnumConstantBody(field);

        if (Objects.nonNull(enumConstantBody) != expectEnumConstantBody) {
            messager.printError("Unexpected body value", field);
        }

        if (enumConstantBody != null) {
            testEnumConstantBody(enumConstantBody, expectedBinaryName, enclosingClass);
        }

        System.out.println("\t constant body " + enumConstantBody);
    }

    /*
     * From JLS 8.9.1:
     *
     * "The optional class body of an enum constant implicitly
     * declares an anonymous class (15.9.5) that (i) is a direct
     * subclass of the immediately enclosing enum class (8.1.4), and
     * (ii) is final (8.1.1.2). The class body is governed by the
     * usual rules of anonymous classes; in particular it cannot
     * contain any constructors. Instance methods declared in these
     * class bodies may be invoked outside the enclosing enum class
     * only if they override accessible methods in the enclosing enum
     * class (8.4.8)."
     */
    private void testEnumConstantBody(TypeElement enumConstBody, String expectedBinaryName, TypeElement enumClass) {
        if (enumConstBody.getNestingKind() != NestingKind.ANONYMOUS) {
            messager.printError("Class body not an anonymous class", enumConstBody);
        }

        // Get the TypeElement for the direct superclass.
        TypeElement superClass =
            (TypeElement)(((DeclaredType)enumConstBody.getSuperclass()).asElement());

        if (!superClass.equals(enumClass)) {
            messager.printError("Class body is not a direct subclass of the enum", enumConstBody);
        }

        if (!enumConstBody.getModifiers().contains(Modifier.FINAL)) {
            messager.printError("Modifier final missing on class body", enumConstBody);
        }

        if (!elements.getBinaryName(enumConstBody).contentEquals(expectedBinaryName)) {
            messager.printError("Unexpected binary name, expected: " + expectedBinaryName +
                                                       ", but was: " + elements.getBinaryName(enumConstBody), enumConstBody);
        }

        return;
    }


    @interface ExpectedBinaryName {
        String value();
    }

    // Nested classes hosting a variety of different kinds of fields.

    private static enum Body {
        @ExpectedBinaryName("TestGetEnumConstantBody$Body$1")
        GOLGI(true) {
            public boolean isOrganelle() {return true;}
        },

        @ExpectedBinaryName("TestGetEnumConstantBody$Body$2")
        HEAVENLY(true) {
            public boolean isCelestial() {return true;}
        };

        private Body(boolean predicate) {
            this.predicate = predicate;
        }

        private boolean predicate;

        public static int field = 42;

        public void method() {return;}
    }

    private static enum MetaSyntaxVar {
        FOO("foo"),
        BAR("bar");

        private String lower;
        private MetaSyntaxVar(String lower) {
            this.lower = lower;
        }

        int   BAZ  = 0;
        float QUUX = 0.1f;
    }

    // Instance and static fields.
    public static class FieldHolder {
        public static final int f1 = 1;
        public static final String s = "s";

        private Object data;
        public FieldHolder(Object data) {
            this.data = data;
        }
    }
}