@NotNull
private Parameters getMethodParametersWithCaptured(
@NotNull ParametersBuilder capturedBuilder, @NotNull MethodNode sourceNode) {
ParametersBuilder builder =
ParametersBuilder.initializeBuilderFrom(oldObjectType, sourceNode.desc);
for (CapturedParamInfo param : capturedBuilder.listCaptured()) {
builder.addCapturedParamCopy(param);
}
return builder.buildParameters();
}
@NotNull
private InlineResult inlineMethod(
@NotNull AnonymousObjectGeneration anonymousObjectGen,
@NotNull FieldRemapper parentRemapper,
@NotNull MethodVisitor deferringVisitor,
@NotNull MethodNode sourceNode,
@NotNull ParametersBuilder capturedBuilder,
boolean isConstructor) {
ReifiedTypeParametersUsages typeParametersToReify =
inliningContext.reifedTypeInliner.reifyInstructions(sourceNode);
Parameters parameters =
isConstructor
? capturedBuilder.buildParameters()
: getMethodParametersWithCaptured(capturedBuilder, sourceNode);
RegeneratedLambdaFieldRemapper remapper =
new RegeneratedLambdaFieldRemapper(
oldObjectType.getInternalName(),
newLambdaType.getInternalName(),
parameters,
anonymousObjectGen.getCapturedLambdasToInline(),
parentRemapper,
isConstructor);
MethodInliner inliner =
new MethodInliner(
sourceNode,
parameters,
inliningContext.subInline(inliningContext.nameGenerator.subGenerator("lambda")),
remapper,
isSameModule,
"Transformer for " + anonymousObjectGen.getOwnerInternalName(),
sourceMapper,
new InlineCallSiteInfo(
anonymousObjectGen.getOwnerInternalName(),
sourceNode.name,
isConstructor
? anonymousObjectGen.getNewConstructorDescriptor()
: sourceNode.desc));
InlineResult result =
inliner.doInline(
deferringVisitor,
new LocalVarRemapper(parameters, 0),
false,
LabelOwner.NOT_APPLICABLE);
result.getReifiedTypeParametersUsages().mergeAll(typeParametersToReify);
deferringVisitor.visitMaxs(-1, -1);
return result;
}
private void generateConstructorAndFields(
@NotNull ClassBuilder classBuilder,
@NotNull ParametersBuilder allCapturedBuilder,
@NotNull ParametersBuilder constructorInlineBuilder,
@NotNull AnonymousObjectGeneration anonymousObjectGen,
@NotNull FieldRemapper parentRemapper,
@NotNull List<CapturedParamInfo> constructorAdditionalFakeParams) {
List<Type> descTypes = new ArrayList<Type>();
Parameters constructorParams = constructorInlineBuilder.buildParameters();
int[] capturedIndexes =
new int[constructorParams.getReal().size() + constructorParams.getCaptured().size()];
int index = 0;
int size = 0;
// complex processing cause it could have super constructor call params
for (ParameterInfo info : constructorParams) {
if (!info.isSkipped()) { // not inlined
if (info.isCaptured() || info instanceof CapturedParamInfo) {
capturedIndexes[index] = size;
index++;
}
if (size != 0) { // skip this
descTypes.add(info.getType());
}
size += info.getType().getSize();
}
}
String constructorDescriptor =
Type.getMethodDescriptor(Type.VOID_TYPE, descTypes.toArray(new Type[descTypes.size()]));
// TODO for inline method make public class
anonymousObjectGen.setNewConstructorDescriptor(constructorDescriptor);
MethodVisitor constructorVisitor =
classBuilder.newMethod(
NO_ORIGIN,
AsmUtil.NO_FLAG_PACKAGE_PRIVATE,
"<init>",
constructorDescriptor,
null,
ArrayUtil.EMPTY_STRING_ARRAY);
// initialize captured fields
List<NewJavaField> newFieldsWithSkipped =
TransformationUtilsKt.getNewFieldsToGenerate(allCapturedBuilder.listCaptured());
List<FieldInfo> fieldInfoWithSkipped =
TransformationUtilsKt.transformToFieldInfo(newLambdaType, newFieldsWithSkipped);
int paramIndex = 0;
InstructionAdapter capturedFieldInitializer = new InstructionAdapter(constructorVisitor);
for (int i = 0; i < fieldInfoWithSkipped.size(); i++) {
FieldInfo fieldInfo = fieldInfoWithSkipped.get(i);
if (!newFieldsWithSkipped.get(i).getSkip()) {
AsmUtil.genAssignInstanceFieldFromParam(
fieldInfo, capturedIndexes[paramIndex], capturedFieldInitializer);
}
paramIndex++;
}
// then transform constructor
// HACK: in inlinining into constructor we access original captured fields with field access not
// local var
// but this fields added to general params (this assumes local var access) not captured one,
// so we need to add them to captured params
for (CapturedParamInfo info : constructorAdditionalFakeParams) {
CapturedParamInfo fake = constructorInlineBuilder.addCapturedParamCopy(info);
if (fake.getLambda() != null) {
// set remap value to skip this fake (captured with lambda already skipped)
StackValue composed =
StackValue.field(
fake.getType(), oldObjectType, fake.getNewFieldName(), false, StackValue.LOCAL_0);
fake.setRemapValue(composed);
}
}
inlineMethodAndUpdateGlobalResult(
anonymousObjectGen,
parentRemapper,
capturedFieldInitializer,
constructor,
constructorInlineBuilder,
true);
constructorVisitor.visitEnd();
AsmUtil.genClosureFields(
TransformationUtilsKt.toNameTypePair(
TransformationUtilsKt.filterSkipped(newFieldsWithSkipped)),
classBuilder);
}