private SMAP generateMethodBody(
@NotNull MethodVisitor adapter,
@NotNull FunctionDescriptor descriptor,
@NotNull MethodContext context,
@NotNull JetExpression expression,
@NotNull JvmMethodSignature jvmMethodSignature,
boolean isLambda) {
FakeMemberCodegen parentCodegen =
new FakeMemberCodegen(
codegen.getParentCodegen(),
expression,
(FieldOwnerContext) context.getParentContext(),
isLambda
? codegen.getParentCodegen().getClassName()
: typeMapper.mapOwner(descriptor).getInternalName());
FunctionGenerationStrategy strategy =
expression instanceof JetCallableReferenceExpression
? new FunctionReferenceGenerationStrategy(
state,
descriptor,
CallUtilKt.getResolvedCallWithAssert(
((JetCallableReferenceExpression) expression).getCallableReference(),
codegen.getBindingContext()))
: new FunctionGenerationStrategy.FunctionDefault(
state, descriptor, (JetDeclarationWithBody) expression);
FunctionCodegen.generateMethodBody(
adapter,
descriptor,
context,
jvmMethodSignature,
strategy,
// Wrapping for preventing marking actual parent codegen as containing reifier markers
parentCodegen);
return createSMAPWithDefaultMapping(
expression, parentCodegen.getOrCreateSourceMapper().getResultMappings());
}
public void generateMethod(
@NotNull JvmDeclarationOrigin origin,
@NotNull FunctionDescriptor functionDescriptor,
@NotNull MethodContext methodContext,
@NotNull FunctionGenerationStrategy strategy) {
OwnerKind contextKind = methodContext.getContextKind();
if (isInterface(functionDescriptor.getContainingDeclaration())
&& functionDescriptor.getVisibility() == Visibilities.PRIVATE
&& contextKind != OwnerKind.DEFAULT_IMPLS) {
return;
}
JvmMethodSignature jvmSignature = typeMapper.mapSignature(functionDescriptor, contextKind);
Method asmMethod = jvmSignature.getAsmMethod();
int flags = getMethodAsmFlags(functionDescriptor, contextKind);
boolean isNative = NativeKt.hasNativeAnnotation(functionDescriptor);
if (isNative && owner instanceof MultifileClassFacadeContext) {
// Native methods are only defined in facades and do not need package part implementations
return;
}
MethodVisitor mv =
v.newMethod(
origin,
flags,
asmMethod.getName(),
asmMethod.getDescriptor(),
jvmSignature.getGenericsSignature(),
getThrownExceptions(functionDescriptor, typeMapper));
if (CodegenContextUtil.isImplClassOwner(owner)) {
v.getSerializationBindings().put(METHOD_FOR_FUNCTION, functionDescriptor, asmMethod);
}
generateMethodAnnotations(functionDescriptor, asmMethod, mv);
generateParameterAnnotations(
functionDescriptor, mv, typeMapper.mapSignature(functionDescriptor));
generateBridges(functionDescriptor);
boolean staticInCompanionObject =
AnnotationUtilKt.isPlatformStaticInCompanionObject(functionDescriptor);
if (staticInCompanionObject) {
ImplementationBodyCodegen parentBodyCodegen =
(ImplementationBodyCodegen) memberCodegen.getParentCodegen();
parentBodyCodegen.addAdditionalTask(
new JvmStaticGenerator(functionDescriptor, origin, state));
}
if (state.getClassBuilderMode() == ClassBuilderMode.LIGHT_CLASSES
|| isAbstractMethod(functionDescriptor, contextKind)) {
generateLocalVariableTable(
mv,
jvmSignature,
functionDescriptor,
getThisTypeForFunction(functionDescriptor, methodContext, typeMapper),
new Label(),
new Label(),
contextKind);
mv.visitEnd();
return;
}
if (!isNative) {
generateMethodBody(
mv, functionDescriptor, methodContext, jvmSignature, strategy, memberCodegen);
} else if (staticInCompanionObject) {
// native @JvmStatic foo() in companion object should delegate to the static native function
// moved to the outer class
mv.visitCode();
FunctionDescriptor staticFunctionDescriptor =
JvmStaticGenerator.createStaticFunctionDescriptor(functionDescriptor);
JvmMethodSignature jvmMethodSignature =
typeMapper.mapSignature(
memberCodegen.getContext().accessibleDescriptor(staticFunctionDescriptor, null));
Type owningType =
typeMapper.mapClass(
(ClassifierDescriptor) staticFunctionDescriptor.getContainingDeclaration());
generateDelegateToMethodBody(
false, mv, jvmMethodSignature.getAsmMethod(), owningType.getInternalName());
}
endVisit(mv, null, origin.getElement());
}