// Copyright (c) 2022, 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.ir.desugar.desugaredlibrary.apiconversion;

import static com.android.tools.r8.ir.desugar.desugaredlibrary.apiconversion.DesugaredLibraryAPIConverter.methodWithVivifiedTypeInSignature;
import static com.android.tools.r8.ir.desugar.desugaredlibrary.apiconversion.DesugaredLibraryAPIConverter.vivifiedTypeFor;

import com.android.tools.r8.cf.code.CfArrayLoad;
import com.android.tools.r8.cf.code.CfArrayStore;
import com.android.tools.r8.cf.code.CfCheckCast;
import com.android.tools.r8.cf.code.CfConstNumber;
import com.android.tools.r8.cf.code.CfInstruction;
import com.android.tools.r8.cf.code.CfInvoke;
import com.android.tools.r8.cf.code.CfLoad;
import com.android.tools.r8.cf.code.CfNewArray;
import com.android.tools.r8.cf.code.CfReturn;
import com.android.tools.r8.cf.code.CfStackInstruction;
import com.android.tools.r8.cf.code.CfStackInstruction.Opcode;
import com.android.tools.r8.cf.code.CfStore;
import com.android.tools.r8.contexts.CompilationContext.MainThreadContext;
import com.android.tools.r8.contexts.CompilationContext.MethodProcessingContext;
import com.android.tools.r8.contexts.CompilationContext.UniqueContext;
import com.android.tools.r8.graph.AppView;
import com.android.tools.r8.graph.CfCode;
import com.android.tools.r8.graph.DexClass;
import com.android.tools.r8.graph.DexEncodedMethod;
import com.android.tools.r8.graph.DexField;
import com.android.tools.r8.graph.DexItemFactory;
import com.android.tools.r8.graph.DexMethod;
import com.android.tools.r8.graph.DexProgramClass;
import com.android.tools.r8.graph.DexProto;
import com.android.tools.r8.graph.DexType;
import com.android.tools.r8.graph.MethodAccessFlags;
import com.android.tools.r8.graph.ProgramMethod;
import com.android.tools.r8.ir.code.MemberType;
import com.android.tools.r8.ir.code.ValueType;
import com.android.tools.r8.ir.desugar.CfInstructionDesugaringEventConsumer;
import com.android.tools.r8.ir.desugar.FreshLocalProvider;
import com.android.tools.r8.ir.desugar.LocalStackAllocator;
import com.android.tools.r8.ir.desugar.desugaredlibrary.apiconversion.DesugaredLibraryWrapperSynthesizerEventConsumer.DesugaredLibraryAPICallbackSynthesizorEventConsumer;
import com.android.tools.r8.ir.desugar.desugaredlibrary.apiconversion.DesugaredLibraryWrapperSynthesizerEventConsumer.DesugaredLibraryAPIConverterEventConsumer;
import com.android.tools.r8.ir.desugar.desugaredlibrary.apiconversion.DesugaredLibraryWrapperSynthesizerEventConsumer.DesugaredLibraryClasspathWrapperSynthesizeEventConsumer;
import com.android.tools.r8.ir.desugar.desugaredlibrary.apiconversion.DesugaredLibraryWrapperSynthesizerEventConsumer.DesugaredLibraryL8ProgramWrapperSynthesizerEventConsumer;
import com.android.tools.r8.ir.synthetic.apiconverter.APIConversionCfCodeProvider;
import com.android.tools.r8.ir.synthetic.apiconverter.EqualsCfCodeProvider;
import com.android.tools.r8.ir.synthetic.apiconverter.HashCodeCfCodeProvider;
import com.android.tools.r8.utils.OptionalBool;
import java.util.ArrayList;
import java.util.Collection;
import java.util.function.BiFunction;
import java.util.function.Supplier;
import org.objectweb.asm.Opcodes;

public class DesugaredLibraryConversionCfProvider {

  private final AppView<?> appView;
  private final DexItemFactory factory;
  private final DesugaredLibraryWrapperSynthesizer wrapperSynthesizer;

  public DesugaredLibraryConversionCfProvider(
      AppView<?> appView, DesugaredLibraryWrapperSynthesizer wrapperSynthesizer) {
    this.appView = appView;
    this.factory = appView.dexItemFactory();
    this.wrapperSynthesizer = wrapperSynthesizer;
  }

  public DexEncodedMethod generateWrapperConversionWithoutCode(
      DexMethod method, DexField wrapperField) {
    DexMethod methodToInstall =
        methodWithVivifiedTypeInSignature(method, wrapperField.getHolderType(), appView);
    return wrapperSynthesizer.newSynthesizedMethod(methodToInstall, null);
  }

  public DexEncodedMethod generateWrapperConversion(
      DexMethod method,
      DexField wrapperField,
      DesugaredLibraryL8ProgramWrapperSynthesizerEventConsumer eventConsumer,
      Supplier<UniqueContext> contextSupplier) {
    DexClass holderClass = appView.definitionFor(method.getHolderType());
    assert holderClass != null || appView.options().isDesugaredLibraryCompilation();
    boolean isInterface = holderClass == null || holderClass.isInterface();
    ProgramMethod context = resolveContext(method, isInterface);
    DexMethod returnConversion =
        computeReturnConversion(method, true, eventConsumer, context, contextSupplier);
    DexMethod[] parameterConversions =
        computeParameterConversions(method, false, eventConsumer, context, contextSupplier);
    DexMethod methodToInstall =
        convertedMethod(
            method, false, returnConversion, parameterConversions, wrapperField.getHolderType());
    CfCode cfCode =
        new APIConversionCfCodeProvider(
                appView,
                wrapperField.getHolderType(),
                method,
                isInterface,
                returnConversion,
                parameterConversions,
                wrapperField)
            .generateCfCode();
    return wrapperSynthesizer.newSynthesizedMethod(methodToInstall, cfCode);
  }

  public DexEncodedMethod generateWrapperHashCode(DexField wrapperField) {
    return wrapperSynthesizer.newSynthesizedMethod(
        appView
            .dexItemFactory()
            .createMethod(
                wrapperField.getHolderType(),
                appView.dexItemFactory().createProto(appView.dexItemFactory().intType),
                appView.dexItemFactory().hashCodeMethodName),
        new HashCodeCfCodeProvider(appView, wrapperField.getHolderType(), wrapperField)
            .generateCfCode());
  }

  public DexEncodedMethod generateWrapperEquals(DexField wrapperField) {
    return wrapperSynthesizer.newSynthesizedMethod(
        appView
            .dexItemFactory()
            .createMethod(
                wrapperField.getHolderType(),
                appView
                    .dexItemFactory()
                    .createProto(
                        appView.dexItemFactory().booleanType, appView.dexItemFactory().objectType),
                appView.dexItemFactory().equalsMethodName),
        new EqualsCfCodeProvider(appView, wrapperField.getHolderType(), wrapperField)
            .generateCfCode());
  }

  public DexEncodedMethod generateVivifiedWrapperConversionWithoutCode(
      DexMethod method, DexField wrapperField) {
    DexMethod methodToInstall =
        factory.createMethod(wrapperField.getHolderType(), method.proto, method.name);
    return wrapperSynthesizer.newSynthesizedMethod(methodToInstall, null);
  }

  public DexEncodedMethod generateVivifiedWrapperConversion(
      DexMethod method,
      DexField wrapperField,
      DesugaredLibraryL8ProgramWrapperSynthesizerEventConsumer eventConsumer,
      Supplier<UniqueContext> contextSupplier) {
    DexMethod methodToInstall =
        factory.createMethod(wrapperField.getHolderType(), method.proto, method.name);
    DexClass holderClass = appView.definitionFor(method.getHolderType());
    boolean isInterface;
    if (holderClass == null) {
      assert appView
          .options()
          .machineDesugaredLibrarySpecification
          .isEmulatedInterfaceRewrittenType(method.getHolderType());
      isInterface = true;
    } else {
      isInterface = holderClass.isInterface();
    }
    ProgramMethod context = resolveContext(method, isInterface);
    DexMethod returnConversion =
        computeReturnConversion(method, false, eventConsumer, context, contextSupplier);
    DexMethod[] parameterConversions =
        computeParameterConversions(method, true, eventConsumer, context, contextSupplier);
    DexType newHolder =
        appView.typeRewriter.hasRewrittenType(method.getHolderType(), appView)
            ? vivifiedTypeFor(method.getHolderType(), appView)
            : method.getHolderType();
    DexMethod forwardMethod =
        convertedMethod(method, true, returnConversion, parameterConversions, newHolder);
    CfCode cfCode =
        new APIConversionCfCodeProvider(
                appView,
                wrapperField.getHolderType(),
                forwardMethod,
                isInterface,
                returnConversion,
                parameterConversions,
                wrapperField)
            .generateCfCode();
    return wrapperSynthesizer.newSynthesizedMethod(methodToInstall, cfCode);
  }

  public ProgramMethod generateCallbackConversion(
      ProgramMethod method,
      DesugaredLibraryAPICallbackSynthesizorEventConsumer eventConsumer,
      MainThreadContext context) {
    DexProgramClass clazz = method.getHolder();
    DexMethod returnConversion =
        computeReturnConversion(
            method.getReference(),
            true,
            eventConsumer,
            method,
            () -> context.createUniqueContext(clazz));
    DexMethod[] parameterConversions =
        computeParameterConversions(
            method.getReference(),
            false,
            eventConsumer,
            method,
            () -> context.createUniqueContext(clazz));
    DexMethod methodToInstall =
        convertedMethod(method.getReference(), false, returnConversion, parameterConversions);
    CfCode cfCode =
        new APIConversionCfCodeProvider(
                appView,
                method.getHolderType(),
                method.getReference(),
                clazz.isInterface(),
                returnConversion,
                parameterConversions)
            .generateCfCode();
    DexEncodedMethod newMethod = wrapperSynthesizer.newSynthesizedMethod(methodToInstall, cfCode);
    newMethod.setCode(cfCode, DexEncodedMethod.NO_PARAMETER_INFO);
    if (method.getDefinition().isLibraryMethodOverride().isTrue()) {
      newMethod.setLibraryMethodOverride(OptionalBool.TRUE);
    }
    ProgramMethod callback = new ProgramMethod(clazz, newMethod);
    assert eventConsumer != null;
    eventConsumer.acceptAPIConversionCallback(callback);
    return callback;
  }

  public ProgramMethod generateOutlinedAPIConversion(
      CfInvoke invoke,
      DesugaredLibraryAPIConverterEventConsumer eventConsumer,
      ProgramMethod context,
      MethodProcessingContext methodProcessingContext) {
    DexMethod method = invoke.getMethod();
    DexProto newProto =
        invoke.isInvokeStatic()
            ? method.proto
            : factory.prependTypeToProto(method.getHolderType(), method.getProto());
    DexMethod returnConversion =
        computeReturnConversion(
            method, false, eventConsumer, context, methodProcessingContext::createUniqueContext);
    DexMethod[] parameterConversions =
        computeParameterConversions(
            method, true, eventConsumer, context, methodProcessingContext::createUniqueContext);
    ProgramMethod outline =
        appView
            .getSyntheticItems()
            .createMethod(
                kinds -> kinds.API_CONVERSION,
                methodProcessingContext.createUniqueContext(),
                appView,
                builder ->
                    builder
                        .setProto(newProto)
                        .setAccessFlags(MethodAccessFlags.createPublicStaticSynthetic())
                        // Will be traced by the enqueuer.
                        .disableAndroidApiLevelCheck()
                        .setCode(
                            methodSignature ->
                                new APIConversionCfCodeProvider(
                                        appView,
                                        methodSignature.holder,
                                        convertedMethod(
                                            method, true, returnConversion, parameterConversions),
                                        invoke.isInterface(),
                                        returnConversion,
                                        parameterConversions,
                                        invoke.getOpcode())
                                    .generateCfCode()));
    eventConsumer.acceptAPIConversion(outline);
    return outline;
  }

  public Collection<CfInstruction> generateInlinedAPIConversion(
      CfInvoke invoke,
      MethodProcessingContext methodProcessingContext,
      FreshLocalProvider freshLocalProvider,
      LocalStackAllocator localStackAllocator,
      CfInstructionDesugaringEventConsumer eventConsumer,
      ProgramMethod context) {

    DexMethod invokedMethod = invoke.getMethod();
    DexMethod returnConversion =
        computeReturnConversion(
            invokedMethod,
            false,
            eventConsumer,
            context,
            methodProcessingContext::createUniqueContext);
    DexMethod[] parameterConversions =
        computeParameterConversions(
            invokedMethod,
            true,
            eventConsumer,
            context,
            methodProcessingContext::createUniqueContext);

    int parameterSize = invokedMethod.getParameters().size();
    ArrayList<CfInstruction> cfInstructions = new ArrayList<>();
    if (parameterSize != 0) {
      // If only the last 2 parameters require conversion, we do everything inlined.
      // If other parameters require conversion, we outline the parameter conversion but keep the
      // API
      // call inlined. The returned value is always converted inlined.
      boolean requireOutlinedParameterConversion = false;
      for (int i = 0; i < parameterConversions.length - 2; i++) {
        requireOutlinedParameterConversion |= parameterConversions[i] != null;
      }
      // We cannot use the swap instruction if the last parameter is wide.
      requireOutlinedParameterConversion |=
          invokedMethod.getParameters().get(parameterSize - 1).isWideType();

      if (requireOutlinedParameterConversion) {
        addOutlineParameterConversionInstructions(
            parameterConversions,
            cfInstructions,
            methodProcessingContext,
            invokedMethod,
            freshLocalProvider,
            localStackAllocator,
            eventConsumer);
      } else {
        addInlineParameterConversionInstructions(
            parameterConversions, cfInstructions, invokedMethod);
      }
    }

    DexMethod convertedMethod =
        convertedMethod(invokedMethod, true, returnConversion, parameterConversions);
    cfInstructions.add(new CfInvoke(invoke.getOpcode(), convertedMethod, invoke.isInterface()));

    if (returnConversion != null) {
      cfInstructions.add(new CfInvoke(Opcodes.INVOKESTATIC, returnConversion, false));
    }

    return cfInstructions;
  }

  // The parameters are converted and returned in an array of converted parameters. The parameter
  // array then needs to be unwrapped at the call site.
  private void addOutlineParameterConversionInstructions(
      DexMethod[] parameterConversions,
      ArrayList<CfInstruction> cfInstructions,
      MethodProcessingContext methodProcessingContext,
      DexMethod invokedMethod,
      FreshLocalProvider freshLocalProvider,
      LocalStackAllocator localStackAllocator,
      CfInstructionDesugaringEventConsumer eventConsumer) {
    localStackAllocator.allocateLocalStack(4);
    DexProto newProto =
        appView
            .dexItemFactory()
            .createProto(
                appView.dexItemFactory().objectArrayType, invokedMethod.getParameters().values);
    ProgramMethod parameterConversion =
        appView
            .getSyntheticItems()
            .createMethod(
                kinds -> kinds.API_CONVERSION_PARAMETERS,
                methodProcessingContext.createUniqueContext(),
                appView,
                builder ->
                    builder
                        .setProto(newProto)
                        .setAccessFlags(MethodAccessFlags.createPublicStaticSynthetic())
                        // Will be traced by the enqueuer.
                        .disableAndroidApiLevelCheck()
                        .setCode(
                            methodSignature ->
                                computeParameterConversionCfCode(
                                    methodSignature.holder, invokedMethod, parameterConversions)));
    eventConsumer.acceptAPIConversion(parameterConversion);
    cfInstructions.add(
        new CfInvoke(Opcodes.INVOKESTATIC, parameterConversion.getReference(), false));
    int arrayLocal = freshLocalProvider.getFreshLocal(ValueType.OBJECT.requiredRegisters());
    cfInstructions.add(new CfStore(ValueType.OBJECT, arrayLocal));
    for (int i = 0; i < parameterConversions.length; i++) {
      cfInstructions.add(new CfLoad(ValueType.OBJECT, arrayLocal));
      cfInstructions.add(new CfConstNumber(i, ValueType.INT));
      DexType parameterType =
          parameterConversions[i] != null
              ? parameterConversions[i].getReturnType()
              : invokedMethod.getParameter(i);
      cfInstructions.add(new CfArrayLoad(MemberType.OBJECT));
      if (parameterType.isPrimitiveType()) {
        cfInstructions.add(new CfCheckCast(factory.getBoxedForPrimitiveType(parameterType)));
        DexMethod method = appView.dexItemFactory().getUnboxPrimitiveMethod(parameterType);
        cfInstructions.add(new CfInvoke(Opcodes.INVOKEVIRTUAL, method, false));
      } else {
        cfInstructions.add(new CfCheckCast(parameterType));
      }
    }
  }

  private CfCode computeParameterConversionCfCode(
      DexType holder, DexMethod invokedMethod, DexMethod[] parameterConversions) {
    ArrayList<CfInstruction> cfInstructions = new ArrayList<>();
    cfInstructions.add(new CfConstNumber(parameterConversions.length, ValueType.INT));
    cfInstructions.add(new CfNewArray(factory.objectArrayType));
    int stackIndex = 0;
    for (int i = 0; i < invokedMethod.getArity(); i++) {
      cfInstructions.add(new CfStackInstruction(Opcode.Dup));
      cfInstructions.add(new CfConstNumber(i, ValueType.INT));
      DexType param = invokedMethod.getParameter(i);
      cfInstructions.add(new CfLoad(ValueType.fromDexType(param), stackIndex));
      if (parameterConversions[i] != null) {
        cfInstructions.add(new CfInvoke(Opcodes.INVOKESTATIC, parameterConversions[i], false));
      }
      if (param.isPrimitiveType()) {
        DexMethod method = appView.dexItemFactory().getBoxPrimitiveMethod(param);
        cfInstructions.add(new CfInvoke(Opcodes.INVOKESTATIC, method, false));
      }
      cfInstructions.add(new CfArrayStore(MemberType.OBJECT));
      if (param == appView.dexItemFactory().longType
          || param == appView.dexItemFactory().doubleType) {
        stackIndex++;
      }
      stackIndex++;
    }
    cfInstructions.add(new CfReturn(ValueType.OBJECT));
    return new CfCode(holder, stackIndex + 4, stackIndex, cfInstructions);
  }

  private void addInlineParameterConversionInstructions(
      DexMethod[] parameterConversions,
      ArrayList<CfInstruction> cfInstructions,
      DexMethod invokedMethod) {
    if (parameterConversions.length > 0
        && parameterConversions[parameterConversions.length - 1] != null) {
      cfInstructions.add(
          new CfInvoke(
              Opcodes.INVOKESTATIC, parameterConversions[parameterConversions.length - 1], false));
    }
    if (parameterConversions.length > 1
        && parameterConversions[parameterConversions.length - 2] != null) {
      assert !invokedMethod
          .getParameters()
          .get(invokedMethod.getParameters().size() - 1)
          .isWideType();
      cfInstructions.add(new CfStackInstruction(Opcode.Swap));
      cfInstructions.add(
          new CfInvoke(
              Opcodes.INVOKESTATIC, parameterConversions[parameterConversions.length - 2], false));
      cfInstructions.add(new CfStackInstruction(Opcode.Swap));
    }
  }

  private ProgramMethod resolveContext(DexMethod method, boolean isInterface) {
    // The context is provided to improve the error message with origin and position. If the method
    // is missing from the input, the context is null but the code runs correctly.
    return appView
        .appInfoForDesugaring()
        .resolveMethodLegacy(method, isInterface)
        .getResolvedProgramMethod();
  }

  private DexMethod computeReturnConversion(
      DexMethod invokedMethod,
      boolean destIsVivified,
      DesugaredLibraryClasspathWrapperSynthesizeEventConsumer eventConsumer,
      ProgramMethod context,
      Supplier<UniqueContext> contextSupplier) {
    return internalComputeReturnConversion(
        invokedMethod,
        (returnType, apiConversionCollection) ->
            wrapperSynthesizer.ensureConversionMethod(
                returnType,
                destIsVivified,
                apiConversionCollection,
                eventConsumer,
                contextSupplier),
        context);
  }

  private DexMethod computeReturnConversion(
      DexMethod invokedMethod,
      boolean destIsVivified,
      DesugaredLibraryL8ProgramWrapperSynthesizerEventConsumer eventConsumer,
      ProgramMethod context,
      Supplier<UniqueContext> contextSupplier) {
    return internalComputeReturnConversion(
        invokedMethod,
        (returnType, apiConversionCollection) ->
            wrapperSynthesizer.getExistingProgramConversionMethod(
                returnType,
                destIsVivified,
                apiConversionCollection,
                eventConsumer,
                contextSupplier),
        context);
  }

  private DexMethod internalComputeReturnConversion(
      DexMethod invokedMethod,
      BiFunction<DexType, DexMethod, DexMethod> methodSupplier,
      ProgramMethod context) {
    DexType returnType = invokedMethod.proto.returnType;
    DexMethod apiGenericTypesConversion = getReturnApiGenericConversion(invokedMethod);
    if (wrapperSynthesizer.shouldConvert(
        returnType, apiGenericTypesConversion, invokedMethod, context)) {
      return methodSupplier.apply(returnType, apiGenericTypesConversion);
    }
    return null;
  }

  private DexMethod[] computeParameterConversions(
      DexMethod invokedMethod,
      boolean destIsVivified,
      DesugaredLibraryClasspathWrapperSynthesizeEventConsumer eventConsumer,
      ProgramMethod context,
      Supplier<UniqueContext> contextSupplier) {
    return internalComputeParameterConversions(
        invokedMethod,
        wrapperSynthesizer,
        (argType, apiGenericTypesConversion) ->
            wrapperSynthesizer.ensureConversionMethod(
                argType, destIsVivified, apiGenericTypesConversion, eventConsumer, contextSupplier),
        context);
  }

  private DexMethod[] computeParameterConversions(
      DexMethod invokedMethod,
      boolean destIsVivified,
      DesugaredLibraryL8ProgramWrapperSynthesizerEventConsumer eventConsumer,
      ProgramMethod context,
      Supplier<UniqueContext> contextSupplier) {
    return internalComputeParameterConversions(
        invokedMethod,
        wrapperSynthesizer,
        (argType, apiGenericTypesConversion) ->
            wrapperSynthesizer.getExistingProgramConversionMethod(
                argType, destIsVivified, apiGenericTypesConversion, eventConsumer, contextSupplier),
        context);
  }

  private DexMethod[] internalComputeParameterConversions(
      DexMethod invokedMethod,
      DesugaredLibraryWrapperSynthesizer wrapperSynthesizor,
      BiFunction<DexType, DexMethod, DexMethod> methodSupplier,
      ProgramMethod context) {
    DexMethod[] parameterConversions = new DexMethod[invokedMethod.getArity()];
    DexType[] parameters = invokedMethod.proto.parameters.values;
    for (int i = 0; i < parameters.length; i++) {
      DexMethod apiGenericTypesConversion = getApiGenericConversion(invokedMethod, i);
      DexType argType = parameters[i];
      if (wrapperSynthesizor.shouldConvert(
          argType, apiGenericTypesConversion, invokedMethod, context)) {
        parameterConversions[i] = methodSupplier.apply(argType, apiGenericTypesConversion);
      }
    }
    return parameterConversions;
  }

  public DexMethod getReturnApiGenericConversion(DexMethod method) {
    return getApiGenericConversion(method, method.getArity());
  }

  public DexMethod getApiGenericConversion(DexMethod method, int parameterIndex) {
    DexMethod[] conversions =
        appView
            .options()
            .machineDesugaredLibrarySpecification
            .getApiGenericConversion()
            .get(method);
    return conversions == null ? null : conversions[parameterIndex];
  }

  private DexMethod convertedMethod(
      DexMethod method,
      boolean parameterDestIsVivified,
      DexMethod returnConversion,
      DexMethod[] parameterConversions) {
    return convertedMethod(
        method,
        parameterDestIsVivified,
        returnConversion,
        parameterConversions,
        method.getHolderType());
  }

  private DexMethod convertedMethod(
      DexMethod method,
      boolean parameterDestIsVivified,
      DexMethod returnConversion,
      DexMethod[] parameterConversions,
      DexType newHolder) {
    DexType newReturnType =
        returnConversion != null
            ? parameterDestIsVivified
                ? returnConversion.getParameter(0)
                : returnConversion.getReturnType()
            : method.getReturnType();
    DexType[] newParameterTypes = new DexType[parameterConversions.length];
    for (int i = 0; i < parameterConversions.length; i++) {
      newParameterTypes[i] =
          parameterConversions[i] != null
              ? parameterDestIsVivified
                  ? parameterConversions[i].getReturnType()
                  : parameterConversions[i].getParameter(0)
              : method.getParameter(i);
    }
    DexMethod convertedAPI =
        appView
            .dexItemFactory()
            .createMethod(
                newHolder,
                appView.dexItemFactory().createProto(newReturnType, newParameterTypes),
                method.name);
    assert convertedAPI == methodWithVivifiedTypeInSignature(method, newHolder, appView)
        || appView
            .options()
            .machineDesugaredLibrarySpecification
            .getApiGenericConversion()
            .containsKey(method)
        || invalidType(method, returnConversion, parameterConversions, appView) != null;
    return convertedAPI;
  }

  private static DexType invalidType(
      DexMethod invokedMethod,
      DexMethod returnConversion,
      DexMethod[] parameterConversions,
      AppView<?> appView) {
    DexMethod convertedMethod =
        methodWithVivifiedTypeInSignature(invokedMethod, invokedMethod.holder, appView);
    if (invokedMethod.getReturnType() != convertedMethod.getReturnType()
        && returnConversion == null) {
      return invokedMethod.getReturnType();
    }
    for (int i = 0; i < invokedMethod.getArity(); i++) {
      if (invokedMethod.getParameter(i) != convertedMethod.getParameter(i)
          && parameterConversions[i] == null) {
        return invokedMethod.getParameter(i);
      }
    }
    return null;
  }
}