proguard.backport.LambdaExpression Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of proguard-core Show documentation
ProGuardCORE is a free library to read, analyze, modify, and write Java class files.
There is a newer version: 9.1.6
/*
 * ProGuardCORE -- library to process Java bytecode.
 *
 * Copyright (c) 2002-2021 Guardsquare NV
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package proguard.backport;

import proguard.classfile.*;
import proguard.classfile.attribute.BootstrapMethodInfo;
import proguard.classfile.constant.MethodHandleConstant;
import proguard.classfile.util.*;

/**
 * A small helper class that captures useful information about a lambda expression as encountered in
 * a class file.
 *
 * @author Thomas Neidhart
 */
public class LambdaExpression {
  // The referenced class of the lambda expression.
  public ProgramClass referencedClass;

  // The referenced bootstrap method index.
  public int bootstrapMethodIndex;
  // The referenced bootstrap method info.
  public BootstrapMethodInfo bootstrapMethodInfo;

  // The lambda factory method type.
  public String factoryMethodDescriptor;

  // The implemented interfaces of the Lambda expression.
  public String[] interfaces;

  // The additional bridge method descriptors to be added.
  public String[] bridgeMethodDescriptors;

  // The name and descriptor of the implemented interface method.
  public String interfaceMethod;
  public String interfaceMethodDescriptor;

  // Information regarding the invoked method.
  public int invokedReferenceKind;
  public String invokedClassName;
  public String invokedMethodName;
  public String invokedMethodDesc;

  public Clazz referencedInvokedClass;
  public Method referencedInvokedMethod;

  // The created lambda class.
  public ProgramClass lambdaClass;

  // The index of the lambda expression, used for naming purposes.
  private final int lambdaExpressionIndex;

  /** Creates a new initialized LambdaExpression (except for the lambdaClass). */
  public LambdaExpression(
      ProgramClass referencedClass,
      int bootstrapMethodIndex,
      BootstrapMethodInfo bootstrapMethodInfo,
      String factoryMethodDescriptor,
      String[] interfaces,
      String[] bridgeMethodDescriptors,
      String interfaceMethod,
      String interfaceMethodDescriptor,
      int invokedReferenceKind,
      String invokedClassName,
      String invokedMethodName,
      String invokedMethodDesc,
      Clazz referencedInvokedClass,
      Method referencedInvokedMethod,
      int lambdaExpressionIndex) {
    this.referencedClass = referencedClass;
    this.bootstrapMethodIndex = bootstrapMethodIndex;
    this.bootstrapMethodInfo = bootstrapMethodInfo;
    this.factoryMethodDescriptor = factoryMethodDescriptor;
    this.interfaces = interfaces;
    this.bridgeMethodDescriptors = bridgeMethodDescriptors;
    this.interfaceMethod = interfaceMethod;
    this.interfaceMethodDescriptor = interfaceMethodDescriptor;
    this.invokedReferenceKind = invokedReferenceKind;
    this.invokedClassName = invokedClassName;
    this.invokedMethodName = invokedMethodName;
    this.invokedMethodDesc = invokedMethodDesc;
    this.referencedInvokedClass = referencedInvokedClass;
    this.referencedInvokedMethod = referencedInvokedMethod;
    this.lambdaExpressionIndex = lambdaExpressionIndex;
  }

  /** Returns the class name of the converted anonymous class. */
  public String getLambdaClassName() {
    return String.format("%s$$Lambda$%d", referencedClass.getName(), lambdaExpressionIndex);
  }

  public String getConstructorDescriptor() {
    if (isStateless()) {
      return ClassConstants.METHOD_TYPE_INIT;
    } else {
      int endIndex = factoryMethodDescriptor.indexOf(TypeConstants.METHOD_ARGUMENTS_CLOSE);

      return factoryMethodDescriptor.substring(0, endIndex + 1) + TypeConstants.VOID;
    }
  }

  /** Returns whether the lambda expression is serializable. */
  public boolean isSerializable() {
    for (String interfaceName : interfaces) {
      if (ClassConstants.NAME_JAVA_IO_SERIALIZABLE.equals(interfaceName)) {
        return true;
      }
    }
    return false;
  }

  /** Returns whether the lambda expression is actually a method reference. */
  public boolean isMethodReference() {
    return !isLambdaMethod(invokedMethodName);
  }

  /** Returns whether the lambda expression is stateless. */
  public boolean isStateless() {
    // The lambda expression is stateless if the factory method does
    // not have arguments.
    return ClassUtil.internalMethodParameterCount(factoryMethodDescriptor) == 0;
  }

  /** Returns whether the invoked method is a static interface method. */
  public boolean invokesStaticInterfaceMethod() {
    // We assume unknown classes are not interfaces.
    return invokedReferenceKind == MethodHandleConstant.REF_INVOKE_STATIC
        && referencedInvokedClass != null
        && (referencedInvokedClass.getAccessFlags() & AccessConstants.INTERFACE) != 0;
  }

  /**
   * Returns whether the invoked method is a non-static, private synthetic method in an interface.
   */
  boolean referencesPrivateSyntheticInterfaceMethod() {
    // We assume unknown classes are not interfaces.
    return (referencedInvokedClass != null)
        && (referencedInvokedClass.getAccessFlags() & AccessConstants.INTERFACE) != 0
        && (referencedInvokedMethod.getAccessFlags()
                & (AccessConstants.PRIVATE | AccessConstants.SYNTHETIC))
            != 0;
  }

  /**
   * Returns whether an accessor method is needed to access the invoked method from the lambda
   * class.
   */
  public boolean needsAccessorMethod() {
    // We assume unknown classes don't need an accessor method.
    return referencedInvokedClass != null
        && new MemberFinder()
                .findMethod(
                    lambdaClass, referencedInvokedClass, invokedMethodName, invokedMethodDesc)
            == null;
  }

  /** Returns whether the lambda expression is a method reference to a private constructor. */
  public boolean referencesPrivateConstructor() {
    return invokedReferenceKind == MethodHandleConstant.REF_NEW_INVOKE_SPECIAL
        && ClassConstants.METHOD_NAME_INIT.equals(invokedMethodName)
        && (referencedInvokedMethod.getAccessFlags() & AccessConstants.PRIVATE) != 0;
  }

  // Small Utility methods.

  private static final String LAMBDA_METHOD_PREFIX = "lambda$";

  private static boolean isLambdaMethod(String methodName) {
    return methodName.startsWith(LAMBDA_METHOD_PREFIX);
  }
}