Java Code Examples for org.objectweb.asm.Opcodes#INVOKESPECIAL

@Override
public void visitMethodInsn(int opcode, String owner, String name, String descriptor, boolean isInterface) {
	if (opcode != Opcodes.INVOKESPECIAL) {
		super.visitMethodInsn(opcode, owner, name, descriptor, isInterface);
	}

	if (!owner.equals(ITEM_GROUP) || !name.equals("<init>")) {
		return;
	}

	if (!descriptor.equals("(Ljava/lang/String;)V") && !descriptor.equals("(ILjava/lang/String;)V")) {
		Patchwork.LOGGER.error("Unexpected descriptor for super() in ItemGroup: " + descriptor);
	}

	super.visitMethodInsn(Opcodes.INVOKESPECIAL, PATCHWORK_ITEM_GROUP, name, descriptor, isInterface);
}
 

private void doVisitMethodInsn(
    final int opcode,
    final String owner,
    final String name,
    final String descriptor,
    final boolean isInterface) {
  switch (opcode) {
    case Opcodes.INVOKESPECIAL:
      invokespecial(owner, name, descriptor, isInterface);
      break;
    case Opcodes.INVOKEVIRTUAL:
      invokevirtual(owner, name, descriptor, isInterface);
      break;
    case Opcodes.INVOKESTATIC:
      invokestatic(owner, name, descriptor, isInterface);
      break;
    case Opcodes.INVOKEINTERFACE:
      invokeinterface(owner, name, descriptor);
      break;
    default:
      throw new IllegalArgumentException();
  }
}
 

private void doVisitMethodInsn(
    final int opcode,
    final String owner,
    final String name,
    final String descriptor,
    final boolean isInterface) {
  switch (opcode) {
    case Opcodes.INVOKESPECIAL:
      invokespecial(owner, name, descriptor, isInterface);
      break;
    case Opcodes.INVOKEVIRTUAL:
      invokevirtual(owner, name, descriptor, isInterface);
      break;
    case Opcodes.INVOKESTATIC:
      invokestatic(owner, name, descriptor, isInterface);
      break;
    case Opcodes.INVOKEINTERFACE:
      invokeinterface(owner, name, descriptor);
      break;
    default:
      throw new IllegalArgumentException();
  }
}
 

static String normalizeInterfaceMethodName(String name, boolean isLambda, int opcode) {
  if (isLambda) {
    // Rename lambda method to reflect the new owner.  Not doing so confuses LambdaDesugaring
    // if it's run over this class again. LambdaDesugaring has already renamed the method from
    // its original name to include the interface name at this point.
    return name + DependencyCollector.INTERFACE_COMPANION_SUFFIX;
  }

  switch (opcode) {
    case Opcodes.INVOKESPECIAL:
      // Rename static methods holding default method implementations since their descriptor
      // differs from the original method (due to explicit receiver parameter). This avoids
      // possible clashes with static interface methods or generated stubs for default methods
      // that could otherwise have the same name and descriptor by coincidence.
      return name + DEFAULT_COMPANION_METHOD_SUFFIX;
    case Opcodes.INVOKESTATIC: // moved but with same name
      return name + "$$STATIC$$"; // TODO(b/117453106): Stop renaming static interface methods
    case Opcodes.INVOKEINTERFACE: // not moved
    case Opcodes.INVOKEVIRTUAL: // tolerate being called for non-interface methods
      return name;
    default:
      throw new IllegalArgumentException("Unexpected opcode calling " + name + ": " + opcode);
  }
}
 

@Override
public void visitInsn(int opcode) {
	if ((opcode == Opcodes.ARETURN) || (opcode == Opcodes.IRETURN)
			|| (opcode == Opcodes.LRETURN)
			|| (opcode == Opcodes.FRETURN)
			|| (opcode == Opcodes.DRETURN)) {
		throw new RuntimeException(new UnmodifiableClassException("Constructors are supposed to return void"));
	}
	if (opcode == Opcodes.RETURN) {
		super.visitVarInsn(Opcodes.ALOAD, 0);
		super.visitTypeInsn(Opcodes.NEW, Type.getInternalName(ScottReportingRule.class));
		super.visitInsn(Opcodes.DUP);
		super.visitMethodInsn(Opcodes.INVOKESPECIAL, Type.getInternalName(ScottReportingRule.class), "<init>", "()V", false);

		super.visitFieldInsn(Opcodes.PUTFIELD,
				className, "scottReportingRule",
				Type.getDescriptor(ScottReportingRule.class));
	}
	
	super.visitInsn(opcode);
}
 

private void doVisitMethodInsn(
    final int opcode,
    final String owner,
    final String name,
    final String descriptor,
    final boolean isInterface) {
  switch (opcode) {
    case Opcodes.INVOKESPECIAL:
      invokespecial(owner, name, descriptor, isInterface);
      break;
    case Opcodes.INVOKEVIRTUAL:
      invokevirtual(owner, name, descriptor, isInterface);
      break;
    case Opcodes.INVOKESTATIC:
      invokestatic(owner, name, descriptor, isInterface);
      break;
    case Opcodes.INVOKEINTERFACE:
      invokeinterface(owner, name, descriptor);
      break;
    default:
      throw new IllegalArgumentException();
  }
}
 

@Override
public void visitMethodInsn(
    int opcode, String owner, String name, String descriptor, boolean isInterface) {
  MethodKey methodKey = MethodKey.create(ClassName.create(owner), name, descriptor);
  MemberUseKind useKind = MemberUseKind.fromValue(opcode);

  // Desugar invokevirtual on private instance methods within the same class.
  if (!isInterface
      && useKind == MemberUseKind.INVOKEVIRTUAL
      && methodKey.owner().equals(enclosingMethodKey.owner())
      && nestDigest.isPrivateInstanceMethod(methodKey)) {
    super.visitMethodInsn(Opcodes.INVOKESPECIAL, owner, name, descriptor, isInterface);
    return;
  }

  if ((isInterface || isCrossMateRefInNest(methodKey, enclosingMethodKey))
      && nestDigest.hasAnyUse(methodKey, useKind)) {
    methodKey.accept(useKind, isInterface, methodToBridgeRedirector, mv);
    return;
  }
  super.visitMethodInsn(opcode, owner, name, descriptor, isInterface);
}
 

/**
 * Find the call to <tt>super()</tt> or <tt>this()</tt> in a constructor.
 * This attempts to locate the first call to <tt>&lt;init&gt;</tt> which
 * isn't an inline call to another object ctor being passed into the super
 * invocation.
 * 
 * @param ctor ctor to scan
 * @param superName name of superclass
 * @param ownerName name of owning class
 * @return Call to <tt>super()</tt>, <tt>this()</tt> or
 *      <tt>DelegateInitialiser.NONE</tt> if not found
 */
public static DelegateInitialiser findDelegateInit(MethodNode ctor, String superName, String ownerName) {
    if (!Constants.CTOR.equals(ctor.name)) {
        return DelegateInitialiser.NONE;
    }
    
    int news = 0;
    for (Iterator<AbstractInsnNode> iter = ctor.instructions.iterator(); iter.hasNext();) {
        AbstractInsnNode insn = iter.next();
        if (insn instanceof TypeInsnNode && insn.getOpcode() == Opcodes.NEW) {
            news++;
        } else if (insn instanceof MethodInsnNode && insn.getOpcode() == Opcodes.INVOKESPECIAL) {
            MethodInsnNode methodNode = (MethodInsnNode)insn;
            if (Constants.CTOR.equals(methodNode.name)) {
                if (news > 0) {
                    news--;
                } else {
                    boolean isSuper = methodNode.owner.equals(superName);
                    if (isSuper || methodNode.owner.equals(ownerName)) {
                        return new DelegateInitialiser(methodNode, isSuper);
                    }
                }
            }
        }
    }
    return DelegateInitialiser.NONE;
}
 

@Override
public MethodNode generate() {
    int size = Bytecode.getArgsSize(this.argTypes) + this.returnType.getSize() + (this.targetIsStatic ? 0 : 1);
    MethodNode method = this.createMethod(size, size);
    if (!this.targetIsStatic) {
        method.instructions.add(new VarInsnNode(Opcodes.ALOAD, 0));
    }
    Bytecode.loadArgs(this.argTypes, method.instructions, this.targetIsStatic ? 0 : 1);
    boolean isPrivate = Bytecode.hasFlag(this.targetMethod, Opcodes.ACC_PRIVATE);
    int opcode = this.targetIsStatic ? Opcodes.INVOKESTATIC : (isPrivate ? Opcodes.INVOKESPECIAL : Opcodes.INVOKEVIRTUAL);
    method.instructions.add(new MethodInsnNode(opcode, this.info.getClassNode().name, this.targetMethod.name, this.targetMethod.desc, false));
    method.instructions.add(new InsnNode(this.returnType.getOpcode(Opcodes.IRETURN)));
    return method;
}
 

static int invokeOpcode(Handle invokedMethod) {
  switch (invokedMethod.getTag()) {
    case Opcodes.H_INVOKESTATIC:
      return Opcodes.INVOKESTATIC;
    case Opcodes.H_INVOKEVIRTUAL:
      return Opcodes.INVOKEVIRTUAL;
    case Opcodes.H_INVOKESPECIAL:
    case Opcodes.H_NEWINVOKESPECIAL: // Must be preceded by NEW
      return Opcodes.INVOKESPECIAL;
    case Opcodes.H_INVOKEINTERFACE:
      return Opcodes.INVOKEINTERFACE;
    default:
      throw new UnsupportedOperationException("Don't know how to call " + invokedMethod);
  }
}
 

private void doVisitMethodInsn(
    final int opcode,
    final String owner,
    final String name,
    final String descriptor,
    final boolean isInterface) {
  if (mv != null) {
    mv.visitMethodInsn(opcode, owner, name, descriptor, isInterface);
  }
  if (this.locals == null) {
    labels = null;
    return;
  }
  pop(descriptor);
  if (opcode != Opcodes.INVOKESTATIC) {
    Object value = pop();
    if (opcode == Opcodes.INVOKESPECIAL && name.equals("<init>")) {
      Object initializedValue;
      if (value == Opcodes.UNINITIALIZED_THIS) {
        initializedValue = this.owner;
      } else {
        initializedValue = uninitializedTypes.get(value);
      }
      for (int i = 0; i < locals.size(); ++i) {
        if (locals.get(i) == value) {
          locals.set(i, initializedValue);
        }
      }
      for (int i = 0; i < stack.size(); ++i) {
        if (stack.get(i) == value) {
          stack.set(i, initializedValue);
        }
      }
    }
  }
  pushDescriptor(descriptor);
  labels = null;
}
 

private boolean needsFrameGuard(int opcode, String owner, String name, String desc) {
    if (owner.startsWith("java/") || owner.startsWith("javax/")) {
        //System.out.println("SKIP:: " + owner + "." + name + desc);
        return false;
    }

    // Always create save-point before Continuation methods (like suspend)
    if (CONTINUATION_CLASS_INTERNAL_NAME.equals(owner)) {
        return CONTINUATION_CLASS_CONTINUABLE_METHODS.contains(name);
    }

    // No need to create save-point before constructors -- it's forbidden to suspend in constructors anyway
    if (opcode == Opcodes.INVOKESPECIAL && "<init>".equals(name)) {
        return false;
    }

    if (opcode == Opcodes.INVOKEINTERFACE ||
        opcode == Opcodes.INVOKESPECIAL   ||
        opcode == Opcodes.INVOKESTATIC    ||
        opcode == Opcodes.INVOKEVIRTUAL) {
        ContinuableClassInfo classInfo;
        try {
            classInfo = cciResolver.resolve(owner);
        } catch (IOException ex) {
            throw new RuntimeException(ex);
        }
        return null != classInfo && classInfo.isContinuableMethod(opcode, name, desc, desc);
    }
    return false;
}
 

@Override
public void visitMethodInsn(
    final int opcodeAndSource,
    final String owner,
    final String name,
    final String descriptor,
    final boolean isInterface) {
  if (api < Opcodes.ASM5 && (opcodeAndSource & Opcodes.SOURCE_DEPRECATED) == 0) {
    // Redirect the call to the deprecated version of this method.
    super.visitMethodInsn(opcodeAndSource, owner, name, descriptor, isInterface);
    return;
  }
  int opcode = opcodeAndSource & ~Opcodes.SOURCE_MASK;

  checkVisitCodeCalled();
  checkVisitMaxsNotCalled();
  checkOpcodeMethod(opcode, Method.VISIT_METHOD_INSN);
  if (opcode != Opcodes.INVOKESPECIAL || !"<init>".equals(name)) {
    checkMethodIdentifier(version, name, "name");
  }
  checkInternalName(version, owner, "owner");
  checkMethodDescriptor(version, descriptor);
  if (opcode == Opcodes.INVOKEVIRTUAL && isInterface) {
    throw new IllegalArgumentException("INVOKEVIRTUAL can't be used with interfaces");
  }
  if (opcode == Opcodes.INVOKEINTERFACE && !isInterface) {
    throw new IllegalArgumentException("INVOKEINTERFACE can't be used with classes");
  }
  if (opcode == Opcodes.INVOKESPECIAL && isInterface && (version & 0xFFFF) < Opcodes.V1_8) {
    throw new IllegalArgumentException(
        "INVOKESPECIAL can't be used with interfaces prior to Java 8");
  }
  super.visitMethodInsn(opcodeAndSource, owner, name, descriptor, isInterface);
  ++insnCount;
}
 

private void doVisitMethodInsn(
    final int opcode,
    final String owner,
    final String name,
    final String descriptor,
    final boolean isInterface) {
  checkVisitCodeCalled();
  checkVisitMaxsNotCalled();
  checkOpcodeMethod(opcode, Method.VISIT_METHOD_INSN);
  if (opcode != Opcodes.INVOKESPECIAL || !"<init>".equals(name)) {
    checkMethodIdentifier(version, name, "name");
  }
  checkInternalName(version, owner, "owner");
  checkMethodDescriptor(version, descriptor);
  if (opcode == Opcodes.INVOKEVIRTUAL && isInterface) {
    throw new IllegalArgumentException("INVOKEVIRTUAL can't be used with interfaces");
  }
  if (opcode == Opcodes.INVOKEINTERFACE && !isInterface) {
    throw new IllegalArgumentException("INVOKEINTERFACE can't be used with classes");
  }
  if (opcode == Opcodes.INVOKESPECIAL && isInterface && (version & 0xFFFF) < Opcodes.V1_8) {
    throw new IllegalArgumentException(
        "INVOKESPECIAL can't be used with interfaces prior to Java 8");
  }

  // Calling super.visitMethodInsn requires to call the correct version depending on this.api
  // (otherwise infinite loops can occur). To simplify and to make it easier to automatically
  // remove the backward compatibility code, we inline the code of the overridden method here.
  if (mv != null) {
    mv.visitMethodInsn(opcode, owner, name, descriptor, isInterface);
  }
  ++insnCount;
}
 

public int getOpcode(InstanceMethodInvoke.Type type) {
    switch (type) {
    case INTERFACE:
        return Opcodes.INVOKEINTERFACE;
    case SPECIAL:
        return Opcodes.INVOKESPECIAL;
    case VIRTUAL:
    default:
        return Opcodes.INVOKEVIRTUAL;
    }
}
 

private boolean needsFrameGuard(int opcode, String owner, String name, String desc) {
    if (owner.startsWith("java/") || owner.startsWith("javax/")) {
        //System.out.println("SKIP:: " + owner + "." + name + desc);
        return false;
    }

    // Always create save-point before Continuation methods (like suspend)
    if (CONTINUATION_CLASS_INTERNAL_NAME.equals(owner)) {
        return CONTINUATION_CLASS_CONTINUABLE_METHODS.contains(name);
    }

    // No need to create save-point before constructors -- it's forbidden to suspend in constructors anyway
    if (opcode == Opcodes.INVOKESPECIAL && "<init>".equals(name)) {
        return false;
    }

    if (opcode == Opcodes.INVOKEDYNAMIC) {
        // TODO verify CallSite to be continuable?
        return true;
    }

    if (opcode == Opcodes.INVOKEINTERFACE ||
        opcode == Opcodes.INVOKESPECIAL   ||
        opcode == Opcodes.INVOKESTATIC    ||
        opcode == Opcodes.INVOKEVIRTUAL) {
        ContinuableClassInfo classInfo;
        try {
            classInfo = cciResolver.resolve(owner);
        } catch (IOException ex) {
            throw new RuntimeException(ex);
        }
        return null != classInfo && classInfo.isContinuableMethod(opcode, name, desc, desc);
    }
    return false;
}
 

/**
 * Find the first <tt>&lt;init&gt;</tt> invocation after the specified
 * <tt>NEW</tt> insn 
 * 
 * @param newNode NEW insn
 * @return INVOKESPECIAL opcode of ctor, or null if not found
 */
public MethodInsnNode findInitNodeFor(TypeInsnNode newNode) {
    int start = this.indexOf(newNode);
    for (Iterator<AbstractInsnNode> iter = this.insns.iterator(start); iter.hasNext();) {
        AbstractInsnNode insn = iter.next();
        if (insn instanceof MethodInsnNode && insn.getOpcode() == Opcodes.INVOKESPECIAL) {
            MethodInsnNode methodNode = (MethodInsnNode)insn;
            if (Constants.CTOR.equals(methodNode.name) && methodNode.owner.equals(newNode.desc)) {
                return methodNode;
            }
        }
    }
    return null;
}
 

@Override
public byte[] transform(String name, String transformedName, byte[] basicClass) 
{
	if(basicClass == null)
		return null;

	ClassNode classNode = ASMHelper.readClassFromBytes(basicClass);

	if (transformedName.equals("net.minecraft.item.Item"))
	{
		String desc = ASMHelper.toMethodDescriptor("V");
		MethodNode methodNode = ASMHelper.findMethodNodeOfClass(classNode, "u", "registerItems", desc);

		if (methodNode != null)
		{
			InsnList list = new InsnList();
			AbstractInsnNode node0 = getLineNumber(methodNode.instructions, 1566);
			node0 = ASMHelper.find(methodNode.instructions, new IntInsnNode(Opcodes.SIPUSH, 337));
			node0 = node0.getNext().getNext();
			AbstractInsnNode newNode = new TypeInsnNode(Opcodes.NEW, gi("com/bioxx/tfc2/items/ItemClayBall"));
			methodNode.instructions.insert(node0, newNode);
			methodNode.instructions.remove(node0);

			node0 = newNode.getNext().getNext();
			MethodInsnNode method = new MethodInsnNode(Opcodes.INVOKESPECIAL, gi("com/bioxx/tfc2/items/ItemClayBall"), "<init>", ASMHelper.toMethodDescriptor("V"), false);
			methodNode.instructions.insert(node0, method);
			methodNode.instructions.remove(node0);
		}
		else
		{
			String msg = "Unable to replace vanilla clay_ball item";
			for(MethodNode m : classNode.methods)
			{
				msg += m.name+", ";
			}
			throw new RuntimeException(msg);
		}
	}
	/*else if (transformedName.equals("net.minecraft.world.gen.feature.WorldGenTallGrass") || 
			transformedName.equals("net.minecraft.world.gen.feature.WorldGenDoublePlant"))
	{
		String desc = ASMHelper.toMethodDescriptor("Z",ObfHelper.toObfClassName(ASMConstants.WORLD),ObfHelper.toObfClassName(ASMConstants.RANDOM),ObfHelper.toObfClassName(ASMConstants.BLOCK_POS));
		MethodNode methodNode = ASMHelper.findMethodNodeOfClass(classNode, "b", "generate", desc);

		if (methodNode != null)
		{
			InsnList list = new InsnList();
			methodNode.instructions.clear();
			list.add(new InsnNode(Opcodes.ICONST_1));
			list.add(new InsnNode(Opcodes.IRETURN));
			methodNode.instructions.insert(list);
		}
		else
			throw new RuntimeException("WorldGenTallGrass | WorldGenDoublePlant: generate (b) method not found");
	}*/

	return ASMHelper.writeClassToBytes(classNode);
}
 

@Override
public void visitInvokeDynamicInsn(String name, String desc, Handle bsm, Object... bsmArgs) {
  if (!"java/lang/invoke/LambdaMetafactory".equals(bsm.getOwner())) {
    // Not an invokedynamic for a lambda expression
    super.visitInvokeDynamicInsn(name, desc, bsm, bsmArgs);
    return;
  }

  try {
    Lookup lookup = createLookup(internalName);
    ArrayList<Object> args = new ArrayList<>(bsmArgs.length + 3);
    args.add(lookup);
    args.add(name);
    args.add(MethodType.fromMethodDescriptorString(desc, targetLoader));
    for (Object bsmArg : bsmArgs) {
      args.add(toJvmMetatype(lookup, bsmArg));
    }

    // Both bootstrap methods in LambdaMetafactory expect a MethodHandle as their 5th argument
    // so we can assume bsmArgs[1] (the 5th arg) to be a Handle.
    MethodReferenceBridgeInfo bridgeInfo = queueUpBridgeMethodIfNeeded((Handle) bsmArgs[1]);

    // Resolve the bootstrap method in "host configuration" (this tool's default classloader)
    // since targetLoader may only contain stubs that we can't actually execute.
    // generateLambdaClass() below will invoke the bootstrap method, so a stub isn't enough,
    // and ultimately we don't care if the bootstrap method was even on the bootclasspath
    // when this class was compiled (although it must've been since javac is unhappy otherwise).
    MethodHandle bsmMethod = toMethodHandle(publicLookup(), bsm, /*target*/ false);
    // Give generated classes to have more stable names (b/35643761).  Use BSM's naming scheme
    // but with separate counter for each surrounding class.
    String lambdaClassName = internalName + "$$Lambda$" + (lambdaCount++);
    Type[] capturedTypes = Type.getArgumentTypes(desc);
    boolean needFactory =
        capturedTypes.length != 0
            && !attemptAllocationBeforeArgumentLoads(lambdaClassName, capturedTypes);
    lambdas.generateLambdaClass(
        internalName,
        LambdaInfo.create(
            lambdaClassName,
            desc,
            needFactory,
            bridgeInfo.methodReference(),
            bridgeInfo.bridgeMethod()),
        bsmMethod,
        args);
    if (desc.startsWith("()")) {
      // For stateless lambda classes we'll generate a singleton instance that we can just load
      checkState(capturedTypes.length == 0);
      super.visitFieldInsn(
          Opcodes.GETSTATIC,
          lambdaClassName,
          LambdaClassFixer.SINGLETON_FIELD_NAME,
          desc.substring("()".length()));
    } else if (needFactory) {
      // If we were unable to inline the allocation of the generated lambda class then
      // invoke factory method of generated lambda class with the arguments on the stack
      super.visitMethodInsn(
          Opcodes.INVOKESTATIC,
          lambdaClassName,
          LambdaClassFixer.FACTORY_METHOD_NAME,
          desc,
          /*itf*/ false);
    } else {
      // Otherwise we inserted a new/dup pair of instructions above and now just need to invoke
      // the constructor of generated lambda class with the arguments on the stack
      super.visitMethodInsn(
          Opcodes.INVOKESPECIAL,
          lambdaClassName,
          "<init>",
          Type.getMethodDescriptor(Type.VOID_TYPE, capturedTypes),
          /*itf*/ false);
    }
  } catch (IOException | ReflectiveOperationException e) {
    throw new IllegalStateException(
        "Couldn't desugar invokedynamic for "
            + internalName
            + "."
            + name
            + " using "
            + bsm
            + " with arguments "
            + Arrays.toString(bsmArgs),
        e);
  }
}
 

@Override
public void visitMethodInsn(int opcode, String owner, String name, String desc, boolean itf) {
  // Assume that any static interface methods on the classpath are moved
  if ((itf || owner.equals(interfaceName)) && !bootclasspath.isKnown(owner)) {
    if (name.startsWith("lambda$")) {
      // Redirect lambda invocations to completely remove all lambda methods from interfaces.
      checkArgument(
          !owner.endsWith(DependencyCollector.INTERFACE_COMPANION_SUFFIX),
          "shouldn't consider %s an interface",
          owner);
      if (opcode == Opcodes.INVOKEINTERFACE) {
        opcode = Opcodes.INVOKESTATIC;
        desc = companionDefaultMethodDescriptor(owner, desc);
      } else {
        checkArgument(
            opcode == Opcodes.INVOKESTATIC,
            "Unexpected opcode %s to invoke %s.%s",
            opcode,
            owner,
            name);
      }
      // Reflect that InterfaceDesugaring moves and renames the lambda body method
      name = normalizeInterfaceMethodName(name, /*isLambda=*/ true, opcode);
      owner += DependencyCollector.INTERFACE_COMPANION_SUFFIX;
      itf = false;
      // Record dependency on companion class
      depsCollector.assumeCompanionClass(declaringClass, owner);

      String expectedLambdaMethodName = LambdaDesugaring.uniqueInPackage(owner, name);
      checkState(
          name.equals(expectedLambdaMethodName),
          "Unexpected lambda body method name for %s: real=%s, expected=%s",
          owner,
          name,
          expectedLambdaMethodName);
    } else if ((opcode == Opcodes.INVOKESTATIC || opcode == Opcodes.INVOKESPECIAL)) {
      checkArgument(
          !owner.endsWith(DependencyCollector.INTERFACE_COMPANION_SUFFIX),
          "shouldn't consider %s an interface",
          owner);
      if (opcode == Opcodes.INVOKESPECIAL) {
        // Turn Interface.super.m() into DefiningInterface$$CC.m(receiver). Note that owner
        // always refers to the current type's immediate super-interface, but the default method
        // may be inherited by that interface, so we have to figure out where the method is
        // defined and invoke it in the corresponding companion class (b/73355452).  Note that
        // we're always dealing with interfaces here, and all interface methods are public,
        // so using Class.getMethods should suffice to find inherited methods.  Also note this
        // can only be a default method invocation, no abstract method invocation.
        owner =
            findDefaultMethod(owner, name, desc)
                .getDeclaringClass()
                .getName()
                .replace('.', '/');
        desc = companionDefaultMethodDescriptor(owner, desc);
      }
      name = normalizeInterfaceMethodName(name, /*isLambda=*/ false, opcode);
      owner += DependencyCollector.INTERFACE_COMPANION_SUFFIX;
      opcode = Opcodes.INVOKESTATIC;
      itf = false;
      // Record dependency on companion class
      depsCollector.assumeCompanionClass(declaringClass, owner);
    } // else non-lambda INVOKEINTERFACE, which needs no rewriting
  }
  super.visitMethodInsn(opcode, owner, name, desc, itf);
}