test/jdk/lib/testlibrary/bytecode/jdk/experimental/bytecode/MethodBuilder.java

/*
 * Copyright (c) 2017, 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.
 */

package jdk.experimental.bytecode;

import jdk.experimental.bytecode.CodeBuilder.JumpMode;

import java.util.Iterator;
import java.util.function.Consumer;
import java.util.function.Function;

public class MethodBuilder<S, T, E> extends MemberBuilder<S, T, E, MethodBuilder<S, T, E>> {

    S thisClass;
    ParameterAnnotationsBuilder runtimeVisibleParameterAnnotations;
    ParameterAnnotationsBuilder runtimeInvisibleParameterAnnotations;

    public MethodBuilder(S thisClass, CharSequence name, T type, PoolHelper<S, T, E> pool, TypeHelper<S, T> typeHelper) {
        super(name, type, pool, typeHelper);
        this.thisClass = thisClass;
    }

    public <C extends CodeBuilder<S, T, E, ?>> MethodBuilder<S, T, E> withCode(Function<? super MethodBuilder<S, T, E>, ? extends C> func,
                                                                               Consumer<? super C> code) {
        C codeBuilder = func.apply(this);
        int start = attributes.offset;
        try {
            code.accept(codeBuilder);
        } catch (MacroCodeBuilder.WideJumpException ex) {
            //wide jumps! Redo the code
            ((MacroCodeBuilder<S, T, E, ?>) codeBuilder).jumpMode = JumpMode.WIDE;
            ((MacroCodeBuilder<S, T, E, ?>) codeBuilder).clear();
            code.accept(codeBuilder);
        }

        attributes.writeChar(poolHelper.putUtf8("Code"));
        attributes.writeInt(0);
        codeBuilder.build(attributes);
        int length = attributes.offset - start;
        //avoid using lambda here
        int prevOffset = attributes.offset;
        try {
            attributes.offset = start + 2;
            attributes.writeInt(length - 6);
        } finally {
            attributes.offset = prevOffset;
        }
        nattrs++;
        return this;
    }

    public MethodBuilder<S, T, E> withCode(Consumer<? super CodeBuilder<S, T, E, ?>> code) {
        return withCode(CodeBuilder::new, code);
    }

    @SuppressWarnings({"varargs", "unchecked"})
    public MethodBuilder<S, T, E> withExceptions(S... exceptions) {
        attributes.writeChar(poolHelper.putUtf8("Exceptions"));
        attributes.writeInt(2 + (2 * exceptions.length));
        attributes.writeChar(exceptions.length);
        for (S exception : exceptions) {
            attributes.writeChar(poolHelper.putClass(exception));
        }
        nattrs++;
        return this;
    }

    public MethodBuilder<S, T, E> withParameterAnnotation(AnnotationsBuilder.Kind kind, int nparam, T annoType) {
        getParameterAnnotations(kind).builders[nparam].withAnnotation(annoType, null);
        return this;
    }

    public MethodBuilder<S, T, E> withParameterAnnotation(AnnotationsBuilder.Kind kind, int nparam, T annoType, Consumer<? super AnnotationsBuilder<S, T, E>.AnnotationElementBuilder> annotations) {
        getParameterAnnotations(kind).builders[nparam].withAnnotation(annoType, annotations);
        return this;
    }

    private ParameterAnnotationsBuilder getParameterAnnotations(AnnotationsBuilder.Kind kind) {
        switch (kind) {
            case RUNTIME_INVISIBLE:
                if (runtimeInvisibleParameterAnnotations == null) {
                    runtimeInvisibleParameterAnnotations = new ParameterAnnotationsBuilder();
                }
                return runtimeInvisibleParameterAnnotations;
            case RUNTIME_VISIBLE:
                if (runtimeVisibleParameterAnnotations == null) {
                    runtimeVisibleParameterAnnotations = new ParameterAnnotationsBuilder();
                }
                return runtimeVisibleParameterAnnotations;
        }
        throw new IllegalStateException();
    }

    class ParameterAnnotationsBuilder {

        GrowableByteBuffer parameterAnnos = new GrowableByteBuffer();

        @SuppressWarnings({"unchecked", "rawtypes"})
        AnnotationsBuilder<S, T, E>[] builders = new AnnotationsBuilder[nparams()];

        ParameterAnnotationsBuilder() {
            for (int i = 0; i < builders.length; i++) {
                builders[i] = new AnnotationsBuilder<>(poolHelper, typeHelper);
            }
        }

        byte[] build() {
            parameterAnnos.writeByte(builders.length);
            for (AnnotationsBuilder<S, T, E> builder : builders) {
                parameterAnnos.writeBytes(builder.build());
            }
            return parameterAnnos.bytes();
        }

        int nparams() {
            Iterator<T> paramsIt = typeHelper.parameterTypes(desc);
            int nparams = 0;
            while (paramsIt.hasNext()) {
                paramsIt.next();
                nparams++;
            }
            return nparams;
        }
    }

    @Override
    void addAnnotations() {
        super.addAnnotations();
        if (runtimeInvisibleParameterAnnotations != null) {
            withAttribute("RuntimeInvisibleParameterAnnotations", runtimeInvisibleParameterAnnotations.build());
        }
        if (runtimeVisibleParameterAnnotations != null) {
            withAttribute("RuntimeVisibleParameterAnnotations", runtimeVisibleParameterAnnotations.build());
        }
    }
}