private String getLambdaAccessMethodDesc(Handle implMethod) {
if (implMethod.getTag() == H_INVOKESTATIC) {
// static method call -> keep as-is
return implMethod.getDesc();
} else if (implMethod.getTag() == H_NEWINVOKESPECIAL) {
// constructor call -> change to a a factory method
return Types.changeReturnType(
Type.getObjectType(implMethod.getOwner()), implMethod.getDesc());
} else {
// instance method call -> change to a static method
return Types.prependArgumentType(Type.getObjectType(className), implMethod.getDesc());
}
}
public AnonymousObjectTransformer(
@NotNull String objectInternalName,
@NotNull InliningContext inliningContext,
boolean isSameModule,
@NotNull Type newLambdaType) {
this.isSameModule = isSameModule;
this.state = inliningContext.state;
this.typeMapper = state.getTypeMapper();
this.inliningContext = inliningContext;
this.oldObjectType = Type.getObjectType(objectInternalName);
this.newLambdaType = newLambdaType;
reader = InlineCodegenUtil.buildClassReaderByInternalName(state, objectInternalName);
transformationResult = InlineResult.create();
}
private List<CapturedParamInfo> extractParametersMappingAndPatchConstructor(
@NotNull MethodNode constructor,
@NotNull ParametersBuilder capturedParamBuilder,
@NotNull ParametersBuilder constructorParamBuilder,
@NotNull final AnonymousObjectGeneration anonymousObjectGen,
@NotNull FieldRemapper parentFieldRemapper) {
CapturedParamOwner owner =
new CapturedParamOwner() {
@Override
public Type getType() {
return Type.getObjectType(anonymousObjectGen.getOwnerInternalName());
}
};
Set<LambdaInfo> capturedLambdas =
new LinkedHashSet<LambdaInfo>(); // captured var of inlined parameter
List<CapturedParamInfo> constructorAdditionalFakeParams = new ArrayList<CapturedParamInfo>();
Map<Integer, LambdaInfo> indexToLambda = anonymousObjectGen.getLambdasToInline();
Set<Integer> capturedParams = new HashSet<Integer>();
// load captured parameters and patch instruction list (NB: there is also could be object
// fields)
AbstractInsnNode cur = constructor.instructions.getFirst();
while (cur != null) {
if (cur instanceof FieldInsnNode) {
FieldInsnNode fieldNode = (FieldInsnNode) cur;
String fieldName = fieldNode.name;
if (fieldNode.getOpcode() == Opcodes.PUTFIELD
&& InlineCodegenUtil.isCapturedFieldName(fieldName)) {
boolean isPrevVarNode = fieldNode.getPrevious() instanceof VarInsnNode;
boolean isPrevPrevVarNode =
isPrevVarNode && fieldNode.getPrevious().getPrevious() instanceof VarInsnNode;
if (isPrevPrevVarNode) {
VarInsnNode node = (VarInsnNode) fieldNode.getPrevious().getPrevious();
if (node.var == 0) {
VarInsnNode previous = (VarInsnNode) fieldNode.getPrevious();
int varIndex = previous.var;
LambdaInfo lambdaInfo = indexToLambda.get(varIndex);
String newFieldName =
isThis0(fieldName)
&& shouldRenameThis0(parentFieldRemapper, indexToLambda.values())
? getNewFieldName(fieldName, true)
: fieldName;
CapturedParamInfo info =
capturedParamBuilder.addCapturedParam(
owner,
fieldName,
newFieldName,
Type.getType(fieldNode.desc),
lambdaInfo != null,
null);
if (lambdaInfo != null) {
info.setLambda(lambdaInfo);
capturedLambdas.add(lambdaInfo);
}
constructorAdditionalFakeParams.add(info);
capturedParams.add(varIndex);
constructor.instructions.remove(previous.getPrevious());
constructor.instructions.remove(previous);
AbstractInsnNode temp = cur;
cur = cur.getNext();
constructor.instructions.remove(temp);
continue;
}
}
}
}
cur = cur.getNext();
}
constructorParamBuilder.addThis(oldObjectType, false);
String constructorDesc = anonymousObjectGen.getConstructorDesc();
if (constructorDesc == null) {
// in case of anonymous object with empty closure
constructorDesc = Type.getMethodDescriptor(Type.VOID_TYPE);
}
Type[] types = Type.getArgumentTypes(constructorDesc);
for (Type type : types) {
LambdaInfo info = indexToLambda.get(constructorParamBuilder.getNextValueParameterIndex());
ParameterInfo parameterInfo =
constructorParamBuilder.addNextParameter(type, info != null, null);
parameterInfo.setLambda(info);
if (capturedParams.contains(parameterInfo.getIndex())) {
parameterInfo.setCaptured(true);
} else {
// otherwise it's super constructor parameter
}
}
// For all inlined lambdas add their captured parameters
// TODO: some of such parameters could be skipped - we should perform additional analysis
Map<String, LambdaInfo> capturedLambdasToInline =
new HashMap<String, LambdaInfo>(); // captured var of inlined parameter
List<CapturedParamDesc> allRecapturedParameters = new ArrayList<CapturedParamDesc>();
boolean addCapturedNotAddOuter =
parentFieldRemapper.isRoot()
|| (parentFieldRemapper instanceof InlinedLambdaRemapper
&& parentFieldRemapper.getParent().isRoot());
Map<String, CapturedParamInfo> alreadyAdded = new HashMap<String, CapturedParamInfo>();
for (LambdaInfo info : capturedLambdas) {
if (addCapturedNotAddOuter) {
for (CapturedParamDesc desc : info.getCapturedVars()) {
String key = desc.getFieldName() + "$$$" + desc.getType().getClassName();
CapturedParamInfo alreadyAddedParam = alreadyAdded.get(key);
CapturedParamInfo recapturedParamInfo =
capturedParamBuilder.addCapturedParam(
desc,
alreadyAddedParam != null
? alreadyAddedParam.getNewFieldName()
: getNewFieldName(desc.getFieldName(), false));
StackValue composed =
StackValue.field(
desc.getType(),
oldObjectType, /*TODO owner type*/
recapturedParamInfo.getNewFieldName(),
false,
StackValue.LOCAL_0);
recapturedParamInfo.setRemapValue(composed);
allRecapturedParameters.add(desc);
constructorParamBuilder
.addCapturedParam(recapturedParamInfo, recapturedParamInfo.getNewFieldName())
.setRemapValue(composed);
if (alreadyAddedParam != null) {
recapturedParamInfo.setSkipInConstructor(true);
}
if (isThis0(desc.getFieldName())) {
alreadyAdded.put(key, recapturedParamInfo);
}
}
}
capturedLambdasToInline.put(info.getLambdaClassType().getInternalName(), info);
}
if (parentFieldRemapper instanceof InlinedLambdaRemapper
&& !capturedLambdas.isEmpty()
&& !addCapturedNotAddOuter) {
// lambda with non InlinedLambdaRemapper already have outer
FieldRemapper parent = parentFieldRemapper.getParent();
assert parent instanceof RegeneratedLambdaFieldRemapper;
final Type ownerType = Type.getObjectType(parent.getLambdaInternalName());
CapturedParamDesc desc =
new CapturedParamDesc(
new CapturedParamOwner() {
@Override
public Type getType() {
return ownerType;
}
},
InlineCodegenUtil.THIS,
ownerType);
CapturedParamInfo recapturedParamInfo =
capturedParamBuilder.addCapturedParam(
desc, InlineCodegenUtil.THIS$0 /*outer lambda/object*/);
StackValue composed = StackValue.LOCAL_0;
recapturedParamInfo.setRemapValue(composed);
allRecapturedParameters.add(desc);
constructorParamBuilder
.addCapturedParam(recapturedParamInfo, recapturedParamInfo.getNewFieldName())
.setRemapValue(composed);
}
anonymousObjectGen.setAllRecapturedParameters(allRecapturedParameters);
anonymousObjectGen.setCapturedLambdasToInline(capturedLambdasToInline);
return constructorAdditionalFakeParams;
}