src/main/java/com/android/tools/r8/shaking/KeepClassInfo.java

// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.shaking;

import com.android.tools.r8.graph.DexClass;
import com.android.tools.r8.graph.DexItemFactory;
import com.android.tools.r8.graph.DexProgramClass;
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.utils.InternalOptions;
import java.util.function.Function;

/** Immutable keep requirements for a class. */
public final class KeepClassInfo extends KeepInfo<KeepClassInfo.Builder, KeepClassInfo> {

  // Requires all aspects of a class to be kept.
  private static final KeepClassInfo TOP =
      new Builder()
          .makeTop()
          .disallowClassInlining()
          .disallowHorizontalClassMerging()
          .disallowPermittedSubclassesRemoval()
          .disallowRepackaging()
          .disallowUnusedInterfaceRemoval()
          .disallowVerticalClassMerging()
          .build();

  // Requires no aspects of a class to be kept.
  private static final KeepClassInfo BOTTOM =
      new Builder()
          .makeBottom()
          .allowClassInlining()
          .allowHorizontalClassMerging()
          .allowPermittedSubclassesRemoval()
          .allowRepackaging()
          .allowUnusedInterfaceRemoval()
          .allowVerticalClassMerging()
          .build();

  public static KeepClassInfo top() {
    return TOP;
  }

  public static KeepClassInfo bottom() {
    return BOTTOM;
  }

  public static Joiner newEmptyJoiner() {
    return bottom().joiner();
  }

  private final boolean allowClassInlining;
  private final boolean allowHorizontalClassMerging;
  private final boolean allowPermittedSubclassesRemoval;
  private final boolean allowRepackaging;
  private final boolean allowUnusedInterfaceRemoval;
  private final boolean allowVerticalClassMerging;
  private final boolean checkEnumUnboxed;

  private KeepClassInfo(Builder builder) {
    super(builder);
    this.allowClassInlining = builder.isClassInliningAllowed();
    this.allowHorizontalClassMerging = builder.isHorizontalClassMergingAllowed();
    this.allowPermittedSubclassesRemoval = builder.isPermittedSubclassesRemovalAllowed();
    this.allowRepackaging = builder.isRepackagingAllowed();
    this.allowUnusedInterfaceRemoval = builder.isUnusedInterfaceRemovalAllowed();
    this.allowVerticalClassMerging = builder.isVerticalClassMergingAllowed();
    this.checkEnumUnboxed = builder.isCheckEnumUnboxedEnabled();
  }

  @Override
  Builder builder() {
    return new Builder(this);
  }

  public boolean isCheckEnumUnboxedEnabled(GlobalKeepInfoConfiguration configuration) {
    return internalIsCheckEnumUnboxedEnabled();
  }

  boolean internalIsCheckEnumUnboxedEnabled() {
    return checkEnumUnboxed;
  }

  public boolean isClassInliningAllowed(GlobalKeepInfoConfiguration configuration) {
    return isOptimizationAllowed(configuration)
        && isShrinkingAllowed(configuration)
        && internalIsClassInliningAllowed();
  }

  boolean internalIsClassInliningAllowed() {
    return allowClassInlining;
  }

  public boolean isHorizontalClassMergingAllowed(GlobalKeepInfoConfiguration configuration) {
    return isOptimizationAllowed(configuration)
        && isShrinkingAllowed(configuration)
        && internalIsHorizontalClassMergingAllowed();
  }

  boolean internalIsHorizontalClassMergingAllowed() {
    return allowHorizontalClassMerging;
  }

  public boolean isKotlinMetadataRemovalAllowed(
      GlobalKeepInfoConfiguration configuration, boolean kotlinMetadataKept) {
    return !kotlinMetadataKept
        || !isPinned(configuration)
        || !configuration.isKeepRuntimeVisibleAnnotationsEnabled()
        || isAnnotationRemovalAllowed(configuration);
  }

  public static boolean isKotlinMetadataClassKept(
      DexItemFactory factory,
      InternalOptions options,
      Function<DexType, DexClass> definitionForWithoutExistenceAssert,
      Function<DexProgramClass, KeepClassInfo> getClassInfo) {
    DexType kotlinMetadataType = factory.kotlinMetadataType;
    DexClass kotlinMetadataClass = definitionForWithoutExistenceAssert.apply(kotlinMetadataType);
    return kotlinMetadataClass == null
        || kotlinMetadataClass.isNotProgramClass()
        || !getClassInfo.apply(kotlinMetadataClass.asProgramClass()).isShrinkingAllowed(options);
  }

  public boolean isPermittedSubclassesRemovalAllowed(GlobalKeepInfoConfiguration configuration) {
    return !configuration.isKeepPermittedSubclassesEnabled()
        && internalIsPermittedSubclassesRemovalAllowed();
  }

  boolean internalIsPermittedSubclassesRemovalAllowed() {
    return allowPermittedSubclassesRemoval;
  }

  /**
   * True if an item may be repackaged.
   *
   * <p>This method requires knowledge of the global configuration as that can override the concrete
   * value on a given item.
   */
  public boolean isRepackagingAllowed(GlobalKeepInfoConfiguration configuration) {
    return configuration.isRepackagingEnabled() && internalIsRepackagingAllowed();
  }

  boolean internalIsRepackagingAllowed() {
    return allowRepackaging;
  }

  boolean internalIsUnusedInterfaceRemovalAllowed() {
    return allowUnusedInterfaceRemoval;
  }

  public boolean isVerticalClassMergingAllowed(GlobalKeepInfoConfiguration configuration) {
    return isOptimizationAllowed(configuration)
        && isShrinkingAllowed(configuration)
        && internalIsVerticalClassMergingAllowed();
  }

  boolean internalIsVerticalClassMergingAllowed() {
    return allowVerticalClassMerging;
  }

  public Joiner joiner() {
    assert !isTop();
    return new Joiner(this);
  }

  @Override
  public boolean isTop() {
    return this.equals(top());
  }

  @Override
  public boolean isBottom() {
    return this.equals(bottom());
  }

  public static class Builder extends KeepInfo.Builder<Builder, KeepClassInfo> {

    private boolean allowClassInlining;
    private boolean allowHorizontalClassMerging;
    private boolean allowPermittedSubclassesRemoval;
    private boolean allowRepackaging;
    private boolean allowUnusedInterfaceRemoval;
    private boolean allowVerticalClassMerging;
    private boolean checkEnumUnboxed;

    private Builder() {
      super();
    }

    private Builder(KeepClassInfo original) {
      super(original);
      allowClassInlining = original.internalIsClassInliningAllowed();
      allowHorizontalClassMerging = original.internalIsHorizontalClassMergingAllowed();
      allowPermittedSubclassesRemoval = original.internalIsPermittedSubclassesRemovalAllowed();
      allowRepackaging = original.internalIsRepackagingAllowed();
      allowUnusedInterfaceRemoval = original.internalIsUnusedInterfaceRemovalAllowed();
      allowVerticalClassMerging = original.internalIsVerticalClassMergingAllowed();
      checkEnumUnboxed = original.internalIsCheckEnumUnboxedEnabled();
    }

    // Check enum unboxed.

    public boolean isCheckEnumUnboxedEnabled() {
      return checkEnumUnboxed;
    }

    public Builder setCheckEnumUnboxed(boolean checkEnumUnboxed) {
      this.checkEnumUnboxed = checkEnumUnboxed;
      return self();
    }

    public Builder setCheckEnumUnboxed() {
      return setCheckEnumUnboxed(true);
    }

    public Builder unsetCheckEnumUnboxed() {
      return setCheckEnumUnboxed(false);
    }

    // Class inlining.

    public Builder allowClassInlining() {
      return setAllowClassInlining(true);
    }

    public boolean isClassInliningAllowed() {
      return allowClassInlining;
    }

    private Builder setAllowClassInlining(boolean allowClassInlining) {
      this.allowClassInlining = allowClassInlining;
      return self();
    }

    public Builder disallowClassInlining() {
      return setAllowClassInlining(false);
    }

    // Horizontal class merging.

    public Builder allowHorizontalClassMerging() {
      return setAllowHorizontalClassMerging(true);
    }

    public boolean isHorizontalClassMergingAllowed() {
      return allowHorizontalClassMerging;
    }

    private Builder setAllowHorizontalClassMerging(boolean allowHorizontalClassMerging) {
      this.allowHorizontalClassMerging = allowHorizontalClassMerging;
      return self();
    }

    public Builder disallowHorizontalClassMerging() {
      return setAllowHorizontalClassMerging(false);
    }

    // Permitted subclasses removal.

    public Builder allowPermittedSubclassesRemoval() {
      return setAllowPermittedSubclassesRemoval(true);
    }

    public boolean isPermittedSubclassesRemovalAllowed() {
      return allowPermittedSubclassesRemoval;
    }

    private Builder setAllowPermittedSubclassesRemoval(boolean allowPermittedSubclassesRemoval) {
      this.allowPermittedSubclassesRemoval = allowPermittedSubclassesRemoval;
      return self();
    }

    public Builder disallowPermittedSubclassesRemoval() {
      return setAllowPermittedSubclassesRemoval(false);
    }

    // Repackaging.

    public boolean isRepackagingAllowed() {
      return allowRepackaging;
    }

    private Builder setAllowRepackaging(boolean allowRepackaging) {
      this.allowRepackaging = allowRepackaging;
      return self();
    }

    public Builder allowRepackaging() {
      return setAllowRepackaging(true);
    }

    public Builder disallowRepackaging() {
      return setAllowRepackaging(false);
    }

    // Unused interface removal.

    public Builder allowUnusedInterfaceRemoval() {
      return setAllowUnusedInterfaceRemoval(true);
    }

    public boolean isUnusedInterfaceRemovalAllowed() {
      return allowUnusedInterfaceRemoval;
    }

    private Builder setAllowUnusedInterfaceRemoval(boolean allowUnusedInterfaceRemoval) {
      this.allowUnusedInterfaceRemoval = allowUnusedInterfaceRemoval;
      return self();
    }

    public Builder disallowUnusedInterfaceRemoval() {
      return setAllowUnusedInterfaceRemoval(false);
    }

    // Vertical class merging.

    public Builder allowVerticalClassMerging() {
      return setAllowVerticalClassMerging(true);
    }

    public boolean isVerticalClassMergingAllowed() {
      return allowVerticalClassMerging;
    }

    private Builder setAllowVerticalClassMerging(boolean allowVerticalClassMerging) {
      this.allowVerticalClassMerging = allowVerticalClassMerging;
      return self();
    }

    public Builder disallowVerticalClassMerging() {
      return setAllowVerticalClassMerging(false);
    }

    @Override
    public KeepClassInfo getTopInfo() {
      return TOP;
    }

    @Override
    public KeepClassInfo getBottomInfo() {
      return BOTTOM;
    }

    @Override
    public Builder self() {
      return this;
    }

    @Override
    public boolean isEqualTo(KeepClassInfo other) {
      return internalIsEqualTo(other);
    }

    @Override
    boolean internalIsEqualTo(KeepClassInfo other) {
      return super.internalIsEqualTo(other)
          && isCheckEnumUnboxedEnabled() == other.internalIsCheckEnumUnboxedEnabled()
          && isClassInliningAllowed() == other.internalIsClassInliningAllowed()
          && isHorizontalClassMergingAllowed() == other.internalIsHorizontalClassMergingAllowed()
          && isPermittedSubclassesRemovalAllowed()
              == other.internalIsPermittedSubclassesRemovalAllowed()
          && isRepackagingAllowed() == other.internalIsRepackagingAllowed()
          && isUnusedInterfaceRemovalAllowed() == other.internalIsUnusedInterfaceRemovalAllowed()
          && isVerticalClassMergingAllowed() == other.internalIsVerticalClassMergingAllowed();
    }

    @Override
    public KeepClassInfo doBuild() {
      return new KeepClassInfo(this);
    }

    @Override
    public Builder makeTop() {
      return super.makeTop()
          .disallowClassInlining()
          .disallowHorizontalClassMerging()
          .disallowPermittedSubclassesRemoval()
          .disallowRepackaging()
          .disallowUnusedInterfaceRemoval()
          .disallowVerticalClassMerging()
          .unsetCheckEnumUnboxed();
    }

    @Override
    public Builder makeBottom() {
      return super.makeBottom()
          .allowClassInlining()
          .allowHorizontalClassMerging()
          .allowPermittedSubclassesRemoval()
          .allowRepackaging()
          .allowUnusedInterfaceRemoval()
          .allowVerticalClassMerging()
          .unsetCheckEnumUnboxed();
    }
  }

  public static class Joiner extends KeepInfo.Joiner<Joiner, Builder, KeepClassInfo> {

    public Joiner(KeepClassInfo info) {
      super(info.builder());
    }

    public Joiner disallowClassInlining() {
      builder.disallowClassInlining();
      return self();
    }

    public Joiner disallowHorizontalClassMerging() {
      builder.disallowHorizontalClassMerging();
      return self();
    }

    public Joiner disallowPermittedSubclassesRemoval() {
      builder.disallowPermittedSubclassesRemoval();
      return self();
    }

    public Joiner disallowRepackaging() {
      builder.disallowRepackaging();
      return self();
    }

    public Joiner disallowUnusedInterfaceRemoval() {
      builder.disallowUnusedInterfaceRemoval();
      return self();
    }

    public Joiner disallowVerticalClassMerging() {
      builder.disallowVerticalClassMerging();
      return self();
    }

    public boolean isUnusedInterfaceRemovalAllowed() {
      return builder.isUnusedInterfaceRemovalAllowed();
    }

    public Joiner setCheckEnumUnboxed() {
      builder.setCheckEnumUnboxed();
      return self();
    }

    @Override
    public Joiner asClassJoiner() {
      return this;
    }

    @Override
    public Joiner merge(Joiner joiner) {
      // Should be extended to merge the fields of this class in case any are added.
      return super.merge(joiner)
          .applyIf(joiner.builder.isCheckEnumUnboxedEnabled(), Joiner::setCheckEnumUnboxed)
          .applyIf(!joiner.builder.isClassInliningAllowed(), Joiner::disallowClassInlining)
          .applyIf(
              !joiner.builder.isHorizontalClassMergingAllowed(),
              Joiner::disallowHorizontalClassMerging)
          .applyIf(
              !joiner.builder.isPermittedSubclassesRemovalAllowed(),
              Joiner::disallowPermittedSubclassesRemoval)
          .applyIf(!joiner.builder.isRepackagingAllowed(), Joiner::disallowRepackaging)
          .applyIf(
              !joiner.builder.isUnusedInterfaceRemovalAllowed(),
              Joiner::disallowUnusedInterfaceRemoval)
          .applyIf(
              !joiner.builder.isVerticalClassMergingAllowed(),
              Joiner::disallowVerticalClassMerging);
    }

    @Override
    Joiner self() {
      return this;
    }
  }
}