Class MethodDefinition

src/main/java/io/airlift/bytecode/MethodDefinition.java:41–323

import static org.objectweb.asm.Opcodes.RETURN;

@SuppressWarnings("UnusedDeclaration")
@NotThreadSafe
public class MethodDefinition
{
    private final Scope scope;
    private final ClassDefinition declaringClass;
    private final EnumSet<Access> access;
    private final String name;
    private final List<AnnotationDefinition> annotations = new ArrayList<>();
    private final ParameterizedType returnType;
    private final List<Parameter> parameters;
    private final List<ParameterizedType> parameterTypes;
    private final List<List<AnnotationDefinition>> parameterAnnotations;
    private final List<ParameterizedType> exceptions = new ArrayList<>();

    private final BytecodeBlock body;
    private String comment;

    public MethodDefinition(
            ClassDefinition declaringClass,
            EnumSet<Access> access,
            String name,
            ParameterizedType returnType,
            Parameter... parameters)
    {
        this(declaringClass, access, name, returnType, ImmutableList.copyOf(parameters));
    }

    public MethodDefinition(
            ClassDefinition declaringClass,
            EnumSet<Access> access,
            String name,
            ParameterizedType returnType,
            Iterable<Parameter> parameters)
    {
        checkArgument(Iterables.size(parameters) <= 254, "Too many parameters for method");

        this.declaringClass = declaringClass;
        body = new BytecodeBlock();

        this.access = access;
        this.name = name;
        this.returnType = requireNonNullElseGet(returnType, () -> type(void.class));
        this.parameters = ImmutableList.copyOf(parameters);
        this.parameterTypes = Lists.transform(this.parameters, Parameter::getType);
        this.parameterAnnotations = Streams.stream(parameters)
                .map(input -> new ArrayList<AnnotationDefinition>())
                .collect(toImmutableList());
        Optional<ParameterizedType> thisType = Optional.empty();
        if (!declaringClass.isInterface() && !access.contains(STATIC)) {
            thisType = Optional.of(declaringClass.getType());
        }
        scope = new Scope(thisType, parameters);
    }

    public ClassDefinition getDeclaringClass()
    {
        return declaringClass;