private void generateMethodAnnotations(
@NotNull FunctionDescriptor functionDescriptor, Method asmMethod, MethodVisitor mv) {
AnnotationCodegen annotationCodegen = AnnotationCodegen.forMethod(mv, typeMapper);
if (functionDescriptor instanceof PropertyAccessorDescriptor) {
AnnotationUseSiteTarget target =
functionDescriptor instanceof PropertySetterDescriptor
? PROPERTY_SETTER
: PROPERTY_GETTER;
annotationCodegen.genAnnotations(functionDescriptor, asmMethod.getReturnType(), target);
} else {
annotationCodegen.genAnnotations(functionDescriptor, asmMethod.getReturnType());
}
writePackageFacadeMethodAnnotationsIfNeeded(mv);
}
void generateDefaultIfNeeded(
@NotNull MethodContext owner,
@NotNull FunctionDescriptor functionDescriptor,
@NotNull OwnerKind kind,
@NotNull DefaultParameterValueLoader loadStrategy,
@Nullable JetNamedFunction function) {
DeclarationDescriptor contextClass = owner.getContextDescriptor().getContainingDeclaration();
if (kind != OwnerKind.DEFAULT_IMPLS && isInterface(contextClass)) {
return;
}
if (!isDefaultNeeded(functionDescriptor)) {
return;
}
int flags =
getVisibilityAccessFlag(functionDescriptor)
| getDeprecatedAccessFlag(functionDescriptor)
| ACC_SYNTHETIC;
if (!(functionDescriptor instanceof ConstructorDescriptor)) {
flags |= ACC_STATIC;
}
// $default methods are never private to be accessible from other class files (e.g. inner)
// without the need of synthetic accessors
flags &= ~ACC_PRIVATE;
Method defaultMethod = typeMapper.mapDefaultMethod(functionDescriptor, kind);
MethodVisitor mv =
v.newMethod(
Synthetic(function, functionDescriptor),
flags,
defaultMethod.getName(),
defaultMethod.getDescriptor(),
null,
getThrownExceptions(functionDescriptor, typeMapper));
// Only method annotations are copied to the $default method. Parameter annotations are not
// copied until there are valid use cases;
// enum constructors have two additional synthetic parameters which somewhat complicate this
// task
AnnotationCodegen.forMethod(mv, typeMapper)
.genAnnotations(functionDescriptor, defaultMethod.getReturnType());
if (state.getClassBuilderMode() == ClassBuilderMode.FULL) {
if (this.owner instanceof DelegatingFacadeContext) {
mv.visitCode();
generateFacadeDelegateMethodBody(mv, defaultMethod, (DelegatingFacadeContext) this.owner);
endVisit(mv, "default method delegation", getSourceFromDescriptor(functionDescriptor));
} else {
mv.visitCode();
generateDefaultImplBody(
owner, functionDescriptor, mv, loadStrategy, function, memberCodegen);
endVisit(mv, "default method", getSourceFromDescriptor(functionDescriptor));
}
}
}
private void generateParameterAnnotations(
@NotNull FunctionDescriptor functionDescriptor,
@NotNull MethodVisitor mv,
@NotNull JvmMethodSignature jvmSignature) {
Iterator<ValueParameterDescriptor> iterator =
functionDescriptor.getValueParameters().iterator();
List<JvmMethodParameterSignature> kotlinParameterTypes = jvmSignature.getValueParameters();
for (int i = 0; i < kotlinParameterTypes.size(); i++) {
JvmMethodParameterSignature parameterSignature = kotlinParameterTypes.get(i);
JvmMethodParameterKind kind = parameterSignature.getKind();
if (kind.isSkippedInGenericSignature()) {
markEnumOrInnerConstructorParameterAsSynthetic(mv, i);
continue;
}
if (kind == JvmMethodParameterKind.VALUE) {
ValueParameterDescriptor parameter = iterator.next();
if (parameter.getIndex() != i) {
v.getSerializationBindings().put(INDEX_FOR_VALUE_PARAMETER, parameter, i);
}
AnnotationCodegen annotationCodegen = AnnotationCodegen.forParameter(i, mv, typeMapper);
if (functionDescriptor instanceof PropertySetterDescriptor) {
PropertyDescriptor propertyDescriptor =
((PropertySetterDescriptor) functionDescriptor).getCorrespondingProperty();
Annotated targetedAnnotations =
new AnnotatedWithOnlyTargetedAnnotations(propertyDescriptor);
annotationCodegen.genAnnotations(
targetedAnnotations, parameterSignature.getAsmType(), SETTER_PARAMETER);
}
if (functionDescriptor instanceof ConstructorDescriptor) {
annotationCodegen.genAnnotations(
parameter, parameterSignature.getAsmType(), CONSTRUCTOR_PARAMETER);
} else {
annotationCodegen.genAnnotations(parameter, parameterSignature.getAsmType());
}
} else if (kind == JvmMethodParameterKind.RECEIVER) {
ReceiverParameterDescriptor receiver =
((functionDescriptor instanceof PropertyAccessorDescriptor)
? ((PropertyAccessorDescriptor) functionDescriptor).getCorrespondingProperty()
: functionDescriptor)
.getExtensionReceiverParameter();
if (receiver != null) {
AnnotationCodegen annotationCodegen = AnnotationCodegen.forParameter(i, mv, typeMapper);
Annotated targetedAnnotations =
new AnnotatedWithOnlyTargetedAnnotations(receiver.getType());
annotationCodegen.genAnnotations(
targetedAnnotations, parameterSignature.getAsmType(), RECEIVER);
}
}
}
}