diff --git a/compiler/android-tests/src/org/jetbrains/kotlin/android/tests/run/RunUtils.java b/compiler/android-tests/src/org/jetbrains/kotlin/android/tests/run/RunUtils.java index 21d4b1d47eb..863a7ad2313 100644 --- a/compiler/android-tests/src/org/jetbrains/kotlin/android/tests/run/RunUtils.java +++ b/compiler/android-tests/src/org/jetbrains/kotlin/android/tests/run/RunUtils.java @@ -88,14 +88,7 @@ public class RunUtils { public static void executeOnSeparateThread(@NotNull RunSettings settings) { assert !settings.waitForEnd : "Use execute() instead"; - Thread t = new Thread(new Runnable() { - @Override - public void run() { - RunUtils.run(settings); - } - }); - - t.start(); + new Thread(() -> run(settings)).start(); } private static RunResult run(RunSettings settings) { diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/AsmUtil.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/AsmUtil.java index c91104347d9..1dc3b825a74 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/AsmUtil.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/AsmUtil.java @@ -21,7 +21,6 @@ import com.google.common.collect.Sets; import com.intellij.openapi.util.Pair; import com.intellij.psi.tree.IElementType; import kotlin.Unit; -import kotlin.jvm.functions.Function1; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.builtins.KotlinBuiltIns; @@ -501,14 +500,11 @@ public class AsmUtil { } public static StackValue genToString(StackValue receiver, Type receiverType) { - return StackValue.operation(JAVA_STRING_TYPE, new Function1() { - @Override - public Unit invoke(InstructionAdapter v) { - Type type = stringValueOfType(receiverType); - receiver.put(type, v); - v.invokestatic("java/lang/String", "valueOf", "(" + type.getDescriptor() + ")Ljava/lang/String;", false); - return null; - } + return StackValue.operation(JAVA_STRING_TYPE, v -> { + Type type = stringValueOfType(receiverType); + receiver.put(type, v); + v.invokestatic("java/lang/String", "valueOf", "(" + type.getDescriptor() + ")Ljava/lang/String;", false); + return null; }); } @@ -573,18 +569,15 @@ public class AsmUtil { return StackValue.cmp(opToken, leftType, left, right); } - return StackValue.operation(Type.BOOLEAN_TYPE, new Function1() { - @Override - public Unit invoke(InstructionAdapter v) { - left.put(leftType, v); - right.put(rightType, v); - genAreEqualCall(v); + return StackValue.operation(Type.BOOLEAN_TYPE, v -> { + left.put(leftType, v); + right.put(rightType, v); + genAreEqualCall(v); - if (opToken == KtTokens.EXCLEQ || opToken == KtTokens.EXCLEQEQEQ) { - genInvertBoolean(v); - } - return Unit.INSTANCE; + if (opToken == KtTokens.EXCLEQ || opToken == KtTokens.EXCLEQEQEQ) { + genInvertBoolean(v); } + return Unit.INSTANCE; }); } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ClassFileFactory.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ClassFileFactory.java index 630ea34ceda..aa58c6d3d61 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ClassFileFactory.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ClassFileFactory.java @@ -18,8 +18,6 @@ package org.jetbrains.kotlin.codegen; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.psi.PsiFile; -import com.intellij.util.Function; -import com.intellij.util.containers.ContainerUtil; import kotlin.collections.CollectionsKt; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -130,12 +128,7 @@ public class ClassFileFactory implements OutputFileCollection { @NotNull public List getCurrentOutput() { - return ContainerUtil.map(generators.keySet(), new Function() { - @Override - public OutputFile fun(String relativeClassFilePath) { - return new OutputClassFile(relativeClassFilePath); - } - }); + return CollectionsKt.map(generators.keySet(), OutputClassFile::new); } @Override @@ -183,16 +176,13 @@ public class ClassFileFactory implements OutputFileCollection { private PackagePartRegistry buildNewPackagePartRegistry(@NotNull FqName packageFqName) { String packageFqNameAsString = packageFqName.asString(); - return new PackagePartRegistry() { - @Override - public void addPart(@NotNull String partShortName, @Nullable String facadeShortName) { - PackageParts packageParts = partsGroupedByPackage.get(packageFqNameAsString); - if (packageParts == null) { - packageParts = new PackageParts(packageFqNameAsString); - partsGroupedByPackage.put(packageFqNameAsString, packageParts); - } - packageParts.addPart(partShortName, facadeShortName); + return (partShortName, facadeShortName) -> { + PackageParts packageParts = partsGroupedByPackage.get(packageFqNameAsString); + if (packageParts == null) { + packageParts = new PackageParts(packageFqNameAsString); + partsGroupedByPackage.put(packageFqNameAsString, packageParts); } + packageParts.addPart(partShortName, facadeShortName); }; } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ClosureCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ClosureCodegen.java index cc161a4124d..3d3ee4ddc20 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ClosureCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ClosureCodegen.java @@ -21,7 +21,6 @@ import com.intellij.util.ArrayUtil; import kotlin.Pair; import kotlin.Unit; import kotlin.collections.CollectionsKt; -import kotlin.jvm.functions.Function1; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.codegen.binding.CalculatedClosure; @@ -49,7 +48,6 @@ import org.jetbrains.kotlin.serialization.ProtoBuf; import org.jetbrains.kotlin.types.KotlinType; import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils; import org.jetbrains.kotlin.util.OperatorNameConventions; -import org.jetbrains.org.objectweb.asm.AnnotationVisitor; import org.jetbrains.org.objectweb.asm.MethodVisitor; import org.jetbrains.org.objectweb.asm.Type; import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter; @@ -241,12 +239,9 @@ public class ClosureCodegen extends MemberCodegen { ProtoBuf.Function functionProto = serializer.functionProto(freeLambdaDescriptor).build(); - WriteAnnotationUtilKt.writeKotlinMetadata(v, state, KotlinClassHeader.Kind.SYNTHETIC_CLASS, 0, new Function1() { - @Override - public Unit invoke(AnnotationVisitor av) { - writeAnnotationData(av, serializer, functionProto); - return Unit.INSTANCE; - } + WriteAnnotationUtilKt.writeKotlinMetadata(v, state, KotlinClassHeader.Kind.SYNTHETIC_CLASS, 0, av -> { + writeAnnotationData(av, serializer, functionProto); + return Unit.INSTANCE; }); } @@ -284,22 +279,19 @@ public class ClosureCodegen extends MemberCodegen { public StackValue putInstanceOnStack(@NotNull ExpressionCodegen codegen, @Nullable StackValue functionReferenceReceiver) { return StackValue.operation( functionReferenceTarget != null ? K_FUNCTION : asmType, - new Function1() { - @Override - public Unit invoke(InstructionAdapter v) { - if (isConst(closure)) { - v.getstatic(asmType.getInternalName(), JvmAbi.INSTANCE_FIELD, asmType.getDescriptor()); - } - else { - v.anew(asmType); - v.dup(); - - codegen.pushClosureOnStack(classDescriptor, true, codegen.defaultCallGenerator, functionReferenceReceiver); - v.invokespecial(asmType.getInternalName(), "", constructor.getDescriptor(), false); - } - - return Unit.INSTANCE; + v -> { + if (isConst(closure)) { + v.getstatic(asmType.getInternalName(), JvmAbi.INSTANCE_FIELD, asmType.getDescriptor()); } + else { + v.anew(asmType); + v.dup(); + + codegen.pushClosureOnStack(classDescriptor, true, codegen.defaultCallGenerator, functionReferenceReceiver); + v.invokespecial(asmType.getInternalName(), "", constructor.getDescriptor(), false); + } + + return Unit.INSTANCE; } ); } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/CompilationErrorHandler.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/CompilationErrorHandler.java index ef5b8fb84ac..8fd544ab10a 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/CompilationErrorHandler.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/CompilationErrorHandler.java @@ -17,15 +17,11 @@ package org.jetbrains.kotlin.codegen; public interface CompilationErrorHandler { - - CompilationErrorHandler THROW_EXCEPTION = new CompilationErrorHandler() { - @Override - public void reportException(Throwable exception, String fileUrl) { - if (exception instanceof RuntimeException) { - throw (RuntimeException) exception; - } - throw new IllegalStateException(exception); + CompilationErrorHandler THROW_EXCEPTION = (exception, fileUrl) -> { + if (exception instanceof RuntimeException) { + throw (RuntimeException) exception; } + throw new IllegalStateException(exception); }; void reportException(Throwable exception, String fileUrl); diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/DefaultParameterValueLoader.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/DefaultParameterValueLoader.java index db4d853780e..3e38211ea4f 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/DefaultParameterValueLoader.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/DefaultParameterValueLoader.java @@ -22,19 +22,11 @@ import org.jetbrains.kotlin.psi.KtParameter; import static org.jetbrains.kotlin.resolve.DescriptorToSourceUtils.descriptorToDeclaration; public interface DefaultParameterValueLoader { - StackValue genValue(ValueParameterDescriptor descriptor, ExpressionCodegen codegen); - DefaultParameterValueLoader DEFAULT = new DefaultParameterValueLoader() { - @Override - public StackValue genValue( - ValueParameterDescriptor descriptor, - ExpressionCodegen codegen - ) { - KtParameter jetParameter = (KtParameter) descriptorToDeclaration(descriptor); - assert jetParameter != null; - return codegen.gen(jetParameter.getDefaultValue()); - } + DefaultParameterValueLoader DEFAULT = (descriptor, codegen) -> { + KtParameter ktParameter = (KtParameter) descriptorToDeclaration(descriptor); + assert ktParameter != null; + return codegen.gen(ktParameter.getDefaultValue()); }; } - diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java index a304b30b7d3..1715b58b0bc 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java @@ -28,8 +28,6 @@ import com.intellij.util.containers.Stack; import kotlin.Pair; import kotlin.Unit; import kotlin.collections.CollectionsKt; -import kotlin.jvm.functions.Function0; -import kotlin.jvm.functions.Function1; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.backend.common.CodegenUtil; @@ -496,36 +494,30 @@ public class ExpressionCodegen extends KtVisitor impleme } } - return StackValue.operation(asmType, new Function1() { - @Override - public Unit invoke(InstructionAdapter v) { - Label elseLabel = new Label(); - BranchedValue.Companion.condJump(condition, elseLabel, true, v); + return StackValue.operation(asmType, v -> { + Label elseLabel = new Label(); + BranchedValue.Companion.condJump(condition, elseLabel, true, v); - Label end = new Label(); + Label end = new Label(); - gen(thenExpression, asmType); + gen(thenExpression, asmType); - v.goTo(end); - v.mark(elseLabel); + v.goTo(end); + v.mark(elseLabel); - gen(elseExpression, asmType); + gen(elseExpression, asmType); - markLineNumber(expression, isStatement); - v.mark(end); - return Unit.INSTANCE; - } + markLineNumber(expression, isStatement); + v.mark(end); + return Unit.INSTANCE; }); } @Override public StackValue visitWhileExpression(@NotNull KtWhileExpression expression, StackValue receiver) { - return StackValue.operation(Type.VOID_TYPE, new Function1() { - @Override - public Unit invoke(InstructionAdapter adapter) { - generateWhile(expression); - return Unit.INSTANCE; - } + return StackValue.operation(Type.VOID_TYPE, adapter -> { + generateWhile(expression); + return Unit.INSTANCE; }); } @@ -551,12 +543,9 @@ public class ExpressionCodegen extends KtVisitor impleme @Override public StackValue visitDoWhileExpression(@NotNull KtDoWhileExpression expression, StackValue receiver) { - return StackValue.operation(Type.VOID_TYPE, new Function1() { - @Override - public Unit invoke(InstructionAdapter adapter) { - generateDoWhile(expression); - return Unit.INSTANCE; - } + return StackValue.operation(Type.VOID_TYPE, adapter -> { + generateDoWhile(expression); + return Unit.INSTANCE; }); } @@ -609,12 +598,9 @@ public class ExpressionCodegen extends KtVisitor impleme @Override public StackValue visitForExpression(@NotNull KtForExpression forExpression, StackValue receiver) { - return StackValue.operation(Type.VOID_TYPE, new Function1() { - @Override - public Unit invoke(InstructionAdapter adapter) { - generateFor(forExpression); - return Unit.INSTANCE; - } + return StackValue.operation(Type.VOID_TYPE, adapter -> { + generateFor(forExpression); + return Unit.INSTANCE; }); } @@ -765,15 +751,12 @@ public class ExpressionCodegen extends KtVisitor impleme VariableDescriptor parameterDescriptor = bindingContext.get(VALUE_PARAMETER, loopParameter); loopParameterType = asmType(parameterDescriptor.getType()); loopParameterVar = myFrameMap.enter(parameterDescriptor, loopParameterType); - scheduleLeaveVariable(new Runnable() { - @Override - public void run() { - myFrameMap.leave(parameterDescriptor); - v.visitLocalVariable(parameterDescriptor.getName().asString(), - loopParameterType.getDescriptor(), null, - loopParameterStartLabel, bodyEnd, - loopParameterVar); - } + scheduleLeaveVariable(() -> { + myFrameMap.leave(parameterDescriptor); + v.visitLocalVariable(parameterDescriptor.getName().asString(), + loopParameterType.getDescriptor(), null, + loopParameterStartLabel, bodyEnd, + loopParameterVar); }); } } @@ -796,28 +779,17 @@ public class ExpressionCodegen extends KtVisitor impleme Label destructuringStartLabel = new Label(); List componentDescriptors = - CollectionsKt.map( - destructuringDeclaration.getEntries(), - new Function1() { - @Override - public VariableDescriptor invoke(KtDestructuringDeclarationEntry entry) { - return getVariableDescriptorNotNull(entry); - } - } - ); + CollectionsKt.map(destructuringDeclaration.getEntries(), ExpressionCodegen.this::getVariableDescriptorNotNull); for (VariableDescriptor componentDescriptor : CodegenUtilKt.filterOutDescriptorsWithSpecialNames(componentDescriptors)) { @SuppressWarnings("ConstantConditions") Type componentAsmType = asmType(componentDescriptor.getReturnType()); int componentVarIndex = myFrameMap.enter(componentDescriptor, componentAsmType); - scheduleLeaveVariable(new Runnable() { - @Override - public void run() { - myFrameMap.leave(componentDescriptor); - v.visitLocalVariable(componentDescriptor.getName().asString(), - componentAsmType.getDescriptor(), null, - destructuringStartLabel, bodyEnd, - componentVarIndex); - } + scheduleLeaveVariable(() -> { + myFrameMap.leave(componentDescriptor); + v.visitLocalVariable(componentDescriptor.getName().asString(), + componentAsmType.getDescriptor(), null, + destructuringStartLabel, bodyEnd, + componentVarIndex); }); } @@ -843,12 +815,7 @@ public class ExpressionCodegen extends KtVisitor impleme protected int createLoopTempVariable(Type type) { int varIndex = myFrameMap.enterTemp(type); - scheduleLeaveVariable(new Runnable() { - @Override - public void run() { - myFrameMap.leaveTemp(type); - } - }); + scheduleLeaveVariable(() -> myFrameMap.leaveTemp(type)); return varIndex; } @@ -1387,14 +1354,12 @@ public class ExpressionCodegen extends KtVisitor impleme loopBlockStackElement.targetLabel != null && labelElement.getReferencedName().equals(loopBlockStackElement.targetLabel.getReferencedName())) { Label label = isBreak ? loopBlockStackElement.breakLabel : loopBlockStackElement.continueLabel; - return StackValue.operation(Type.VOID_TYPE, new Function1() { - @Override - public Unit invoke(InstructionAdapter adapter) { - PseudoInsnsKt.fixStackAndJump(v, label); - v.mark(afterBreakContinueLabel); - return Unit.INSTANCE; - } - } + return StackValue.operation( + Type.VOID_TYPE, adapter -> { + PseudoInsnsKt.fixStackAndJump(v, label); + v.mark(afterBreakContinueLabel); + return Unit.INSTANCE; + } ); } } @@ -1416,30 +1381,26 @@ public class ExpressionCodegen extends KtVisitor impleme boolean isStatement ) { Type targetType = isStatement ? Type.VOID_TYPE : expressionType(ifExpression); - return StackValue.operation(targetType, new Function1() { - @Override - public Unit invoke(InstructionAdapter v) { - Label elseLabel = new Label(); - BranchedValue.Companion.condJump(condition, elseLabel, inverse, v); + return StackValue.operation(targetType, v -> { + Label elseLabel = new Label(); + BranchedValue.Companion.condJump(condition, elseLabel, inverse, v); - if (isStatement) { - gen(expression, Type.VOID_TYPE); - v.mark(elseLabel); - } - else { - Type targetType = expressionType(ifExpression); - gen(expression, targetType); - Label end = new Label(); - v.goTo(end); - - v.mark(elseLabel); - StackValue.putUnitInstance(v); - - markStartLineNumber(ifExpression); - v.mark(end); - } - return null; + if (isStatement) { + gen(expression, Type.VOID_TYPE); + v.mark(elseLabel); } + else { + gen(expression, targetType); + Label end = new Label(); + v.goTo(end); + + v.mark(elseLabel); + StackValue.putUnitInstance(v); + + markStartLineNumber(ifExpression); + v.mark(end); + } + return null; }); } @@ -1549,25 +1510,22 @@ public class ExpressionCodegen extends KtVisitor impleme return StackValue.constant(constantValue.toString(), type); } else { - return StackValue.operation(JAVA_STRING_TYPE, new Function1() { - @Override - public Unit invoke(InstructionAdapter v) { - genStringBuilderConstructor(v); - for (KtStringTemplateEntry entry : entries) { - if (entry instanceof KtStringTemplateEntryWithExpression) { - invokeAppend(entry.getExpression()); - } - else { - String text = entry instanceof KtEscapeStringTemplateEntry - ? ((KtEscapeStringTemplateEntry) entry).getUnescapedValue() - : entry.getText(); - v.aconst(text); - genInvokeAppendMethod(v, JAVA_STRING_TYPE); - } + return StackValue.operation(JAVA_STRING_TYPE, v -> { + genStringBuilderConstructor(v); + for (KtStringTemplateEntry entry : entries) { + if (entry instanceof KtStringTemplateEntryWithExpression) { + invokeAppend(entry.getExpression()); + } + else { + String text = entry instanceof KtEscapeStringTemplateEntry + ? ((KtEscapeStringTemplateEntry) entry).getUnescapedValue() + : entry.getText(); + v.aconst(text); + genInvokeAppendMethod(v, JAVA_STRING_TYPE); } - v.invokevirtual("java/lang/StringBuilder", "toString", "()Ljava/lang/String;", false); - return Unit.INSTANCE; } + v.invokevirtual("java/lang/StringBuilder", "toString", "()Ljava/lang/String;", false); + return Unit.INSTANCE; }); } } @@ -1667,56 +1625,53 @@ public class ExpressionCodegen extends KtVisitor impleme ClassDescriptor classDescriptor = objectLiteralResult.classDescriptor; Type type = typeMapper.mapType(classDescriptor); - return StackValue.operation(type, new Function1() { - @Override - public Unit invoke(InstructionAdapter v) { - if (objectLiteralResult.wereReifiedMarkers) { - ReifiedTypeInliner.putNeedClassReificationMarker(v); - } - v.anew(type); - v.dup(); - - pushClosureOnStack(classDescriptor, true, defaultCallGenerator, /* functionReferenceReceiver = */ null); - - ConstructorDescriptor primaryConstructor = classDescriptor.getUnsubstitutedPrimaryConstructor(); - assert primaryConstructor != null : "There should be primary constructor for object literal"; - ResolvedCall superCall = getDelegationConstructorCall(bindingContext, primaryConstructor); - if (superCall != null) { - // For an anonymous object, we should also generate all non-default arguments that it captures for its super call - ConstructorDescriptor superConstructor = superCall.getResultingDescriptor(); - ConstructorDescriptor constructorToCall = SamCodegenUtil.resolveSamAdapter(superConstructor); - List superValueParameters = superConstructor.getValueParameters(); - int params = superValueParameters.size(); - List superMappedTypes = typeMapper.mapToCallableMethod(constructorToCall, false).getValueParameterTypes(); - assert superMappedTypes.size() >= params : String - .format("Incorrect number of mapped parameters vs arguments: %d < %d for %s", - superMappedTypes.size(), params, classDescriptor); - - List valueArguments = new ArrayList(params); - List valueParameters = new ArrayList(params); - List mappedTypes = new ArrayList(params); - for (ValueParameterDescriptor parameter : superValueParameters) { - ResolvedValueArgument argument = superCall.getValueArguments().get(parameter); - if (!(argument instanceof DefaultValueArgument)) { - valueArguments.add(argument); - valueParameters.add(parameter); - mappedTypes.add(superMappedTypes.get(parameter.getIndex())); - } - } - ArgumentGenerator argumentGenerator = - new CallBasedArgumentGenerator(ExpressionCodegen.this, defaultCallGenerator, valueParameters, mappedTypes); - - argumentGenerator.generate(valueArguments, valueArguments, null); - } - - Collection constructors = classDescriptor.getConstructors(); - assert constructors.size() == 1 : "Unexpected number of constructors for class: " + classDescriptor + " " + constructors; - ConstructorDescriptor constructorDescriptor = CollectionsKt.single(constructors); - - Method constructor = typeMapper.mapAsmMethod(SamCodegenUtil.resolveSamAdapter(constructorDescriptor)); - v.invokespecial(type.getInternalName(), "", constructor.getDescriptor(), false); - return Unit.INSTANCE; + return StackValue.operation(type, v -> { + if (objectLiteralResult.wereReifiedMarkers) { + ReifiedTypeInliner.putNeedClassReificationMarker(v); } + v.anew(type); + v.dup(); + + pushClosureOnStack(classDescriptor, true, defaultCallGenerator, /* functionReferenceReceiver = */ null); + + ConstructorDescriptor primaryConstructor = classDescriptor.getUnsubstitutedPrimaryConstructor(); + assert primaryConstructor != null : "There should be primary constructor for object literal"; + ResolvedCall superCall = getDelegationConstructorCall(bindingContext, primaryConstructor); + if (superCall != null) { + // For an anonymous object, we should also generate all non-default arguments that it captures for its super call + ConstructorDescriptor superConstructor = superCall.getResultingDescriptor(); + ConstructorDescriptor constructorToCall = SamCodegenUtil.resolveSamAdapter(superConstructor); + List superValueParameters = superConstructor.getValueParameters(); + int params = superValueParameters.size(); + List superMappedTypes = typeMapper.mapToCallableMethod(constructorToCall, false).getValueParameterTypes(); + assert superMappedTypes.size() >= params : String + .format("Incorrect number of mapped parameters vs arguments: %d < %d for %s", + superMappedTypes.size(), params, classDescriptor); + + List valueArguments = new ArrayList(params); + List valueParameters = new ArrayList(params); + List mappedTypes = new ArrayList(params); + for (ValueParameterDescriptor parameter : superValueParameters) { + ResolvedValueArgument argument = superCall.getValueArguments().get(parameter); + if (!(argument instanceof DefaultValueArgument)) { + valueArguments.add(argument); + valueParameters.add(parameter); + mappedTypes.add(superMappedTypes.get(parameter.getIndex())); + } + } + ArgumentGenerator argumentGenerator = + new CallBasedArgumentGenerator(this, defaultCallGenerator, valueParameters, mappedTypes); + + argumentGenerator.generate(valueArguments, valueArguments, null); + } + + Collection constructors = classDescriptor.getConstructors(); + assert constructors.size() == 1 : "Unexpected number of constructors for class: " + classDescriptor + " " + constructors; + ConstructorDescriptor constructorDescriptor = CollectionsKt.single(constructors); + + Method constructor = typeMapper.mapAsmMethod(SamCodegenUtil.resolveSamAdapter(constructorDescriptor)); + v.invokespecial(type.getInternalName(), "", constructor.getDescriptor(), false); + return Unit.INSTANCE; }); } @@ -1869,17 +1824,14 @@ public class ExpressionCodegen extends KtVisitor impleme assert blockResult != null : "Block result should be initialized in the loop or the condition above"; - return new StackValueWithLeaveTask(blockResult, new Function1() { - @Override - public Unit invoke(StackValue value) { - if (labelBlockEnd == null) { - v.mark(blockEnd); - } - for (Function task : Lists.reverse(leaveTasks)) { - task.fun(value); - } - return Unit.INSTANCE; + return new StackValueWithLeaveTask(blockResult, value -> { + if (labelBlockEnd == null) { + v.mark(blockEnd); } + for (Function task : Lists.reverse(leaveTasks)) { + task.fun(value); + } + return Unit.INSTANCE; }); } @@ -1995,22 +1947,19 @@ public class ExpressionCodegen extends KtVisitor impleme Label scopeStart = new Label(); v.mark(scopeStart); - leaveTasks.add(new Function() { - @Override - public Void fun(StackValue answer) { - if (isDelegatedLocalVariable(variableDescriptor)) { - myFrameMap.leave(getDelegatedLocalVariableMetadata(variableDescriptor, bindingContext)); - } - - int index = myFrameMap.leave(variableDescriptor); - - if (isSharedVarType(type)) { - v.aconst(null); - v.store(index, OBJECT_TYPE); - } - v.visitLocalVariable(variableDescriptor.getName().asString(), type.getDescriptor(), null, scopeStart, blockEnd, index); - return null; + leaveTasks.add(answer -> { + if (isDelegatedLocalVariable(variableDescriptor)) { + myFrameMap.leave(getDelegatedLocalVariableMetadata(variableDescriptor, bindingContext)); } + + int index = myFrameMap.leave(variableDescriptor); + + if (isSharedVarType(type)) { + v.aconst(null); + v.store(index, OBJECT_TYPE); + } + v.visitLocalVariable(variableDescriptor.getName().asString(), type.getDescriptor(), null, scopeStart, blockEnd, index); + return null; }); } @@ -2027,15 +1976,12 @@ public class ExpressionCodegen extends KtVisitor impleme Label scopeStart = new Label(); v.mark(scopeStart); - leaveTasks.add(new Function() { - @Override - public Void fun(StackValue answer) { - int index = myFrameMap.leave(functionDescriptor); + leaveTasks.add(answer -> { + int index = myFrameMap.leave(functionDescriptor); - assert !functionDescriptor.getName().isSpecial() : "Local variable should be generated only for function with name: " + statement.getText(); - v.visitLocalVariable(functionDescriptor.getName().asString() + "$", type.getDescriptor(), null, scopeStart, blockEnd, index); - return null; - } + assert !functionDescriptor.getName().isSpecial() : "Local variable should be generated only for function with name: " + statement.getText(); + v.visitLocalVariable(functionDescriptor.getName().asString() + "$", type.getDescriptor(), null, scopeStart, blockEnd, index); + return null; }); } @@ -2157,39 +2103,36 @@ public class ExpressionCodegen extends KtVisitor impleme @Override public StackValue visitReturnExpression(@NotNull KtReturnExpression expression, StackValue receiver) { - return StackValue.operation(Type.VOID_TYPE, new Function1() { - @Override - public Unit invoke(InstructionAdapter adapter) { - KtExpression returnedExpression = expression.getReturnedExpression(); - CallableMemberDescriptor descriptor = getContext().getContextDescriptor(); - NonLocalReturnInfo nonLocalReturn = getNonLocalReturnInfo(descriptor, expression); - boolean isNonLocalReturn = nonLocalReturn != null; - if (isNonLocalReturn && state.isInlineDisabled()) { - state.getDiagnostics().report(Errors.NON_LOCAL_RETURN_IN_DISABLED_INLINE.on(expression)); - genThrow(v, "java/lang/UnsupportedOperationException", - "Non-local returns are not allowed with inlining disabled"); - return Unit.INSTANCE; - } - - Type returnType = isNonLocalReturn ? nonLocalReturn.returnType : ExpressionCodegen.this.returnType; - StackValue valueToReturn = returnedExpression != null ? gen(returnedExpression) : StackValue.none(); - - putStackValue(returnedExpression, returnType, valueToReturn); - - Label afterReturnLabel = new Label(); - generateFinallyBlocksIfNeeded(returnType, afterReturnLabel); - - if (isNonLocalReturn) { - InlineCodegenUtil.generateGlobalReturnFlag(v, nonLocalReturn.labelName); - v.visitInsn(returnType.getOpcode(Opcodes.IRETURN)); - } - else { - v.areturn(ExpressionCodegen.this.returnType); - } - - v.mark(afterReturnLabel); + return StackValue.operation(Type.VOID_TYPE, adapter -> { + KtExpression returnedExpression = expression.getReturnedExpression(); + CallableMemberDescriptor descriptor = getContext().getContextDescriptor(); + NonLocalReturnInfo nonLocalReturn = getNonLocalReturnInfo(descriptor, expression); + boolean isNonLocalReturn = nonLocalReturn != null; + if (isNonLocalReturn && state.isInlineDisabled()) { + state.getDiagnostics().report(Errors.NON_LOCAL_RETURN_IN_DISABLED_INLINE.on(expression)); + genThrow(v, "java/lang/UnsupportedOperationException", + "Non-local returns are not allowed with inlining disabled"); return Unit.INSTANCE; } + + Type returnType = isNonLocalReturn ? nonLocalReturn.returnType : this.returnType; + StackValue valueToReturn = returnedExpression != null ? gen(returnedExpression) : StackValue.none(); + + putStackValue(returnedExpression, returnType, valueToReturn); + + Label afterReturnLabel = new Label(); + generateFinallyBlocksIfNeeded(returnType, afterReturnLabel); + + if (isNonLocalReturn) { + InlineCodegenUtil.generateGlobalReturnFlag(v, nonLocalReturn.labelName); + v.visitInsn(returnType.getOpcode(Opcodes.IRETURN)); + } + else { + v.areturn(this.returnType); + } + + v.mark(afterReturnLabel); + return Unit.INSTANCE; }); } @@ -2698,33 +2641,30 @@ public class ExpressionCodegen extends KtVisitor impleme Type asmType = state.getSamWrapperClasses().getSamWrapperClass(samType, expression.getContainingKtFile(), this); - return StackValue.operation(asmType, new Function1() { - @Override - public Unit invoke(InstructionAdapter v) { - v.anew(asmType); - v.dup(); + return StackValue.operation(asmType, v -> { + v.anew(asmType); + v.dup(); - Type functionType = typeMapper.mapType(samType.getKotlinFunctionType()); - expression.accept(visitor, StackValue.none()).put(functionType, v); + Type functionType = typeMapper.mapType(samType.getKotlinFunctionType()); + expression.accept(visitor, StackValue.none()).put(functionType, v); - Label ifNonNull = new Label(); - Label afterAll = new Label(); + Label ifNonNull = new Label(); + Label afterAll = new Label(); - v.dup(); - v.ifnonnull(ifNonNull); + v.dup(); + v.ifnonnull(ifNonNull); - // if null: pop function value and wrapper objects, put null - v.pop(); - v.pop2(); - v.aconst(null); - v.goTo(afterAll); + // if null: pop function value and wrapper objects, put null + v.pop(); + v.pop2(); + v.aconst(null); + v.goTo(afterAll); - v.mark(ifNonNull); - v.invokespecial(asmType.getInternalName(), "", Type.getMethodDescriptor(Type.VOID_TYPE, functionType), false); + v.mark(ifNonNull); + v.invokespecial(asmType.getInternalName(), "", Type.getMethodDescriptor(Type.VOID_TYPE, functionType), false); - v.mark(afterAll); - return null; - } + v.mark(afterAll); + return null; }); } @@ -3405,13 +3345,10 @@ public class ExpressionCodegen extends KtVisitor impleme ); codegen.generate(); - return codegen.putInstanceOnStack(receiverValue == null ? null : new Function0() { - @Override - public Unit invoke() { - assert receiverAsmType != null : "Receiver type should not be null when receiver value is not null: " + receiverValue; - receiverValue.put(receiverAsmType, v); - return Unit.INSTANCE; - } + return codegen.putInstanceOnStack(receiverValue == null ? null : () -> { + assert receiverAsmType != null : "Receiver type should not be null when receiver value is not null: " + receiverValue; + receiverValue.put(receiverAsmType, v); + return Unit.INSTANCE; }); } @@ -3421,29 +3358,26 @@ public class ExpressionCodegen extends KtVisitor impleme @Nullable KtExpression receiverExpression, boolean wrapIntoKClass ) { - return StackValue.operation(wrapIntoKClass ? K_CLASS_TYPE : JAVA_CLASS_TYPE, new Function1() { - @Override - public Unit invoke(InstructionAdapter v) { - KotlinType type = lhs.getType(); - if (lhs instanceof DoubleColonLHS.Expression && !((DoubleColonLHS.Expression) lhs).isObjectQualifier()) { - JavaClassProperty.INSTANCE.generateImpl(v, gen(receiverExpression)); - } - else { - if (TypeUtils.isTypeParameter(type)) { - assert TypeUtils.isReifiedTypeParameter(type) : - "Non-reified type parameter under ::class should be rejected by type checker: " + type; - putReifiedOperationMarkerIfTypeIsReifiedParameter(type, ReifiedTypeInliner.OperationKind.JAVA_CLASS); - } - - putJavaLangClassInstance(v, typeMapper.mapType(type)); - } - - if (wrapIntoKClass) { - wrapJavaClassIntoKClass(v); - } - - return Unit.INSTANCE; + return StackValue.operation(wrapIntoKClass ? K_CLASS_TYPE : JAVA_CLASS_TYPE, v -> { + KotlinType type = lhs.getType(); + if (lhs instanceof DoubleColonLHS.Expression && !((DoubleColonLHS.Expression) lhs).isObjectQualifier()) { + JavaClassProperty.INSTANCE.generateImpl(v, gen(receiverExpression)); } + else { + if (TypeUtils.isTypeParameter(type)) { + assert TypeUtils.isReifiedTypeParameter(type) : + "Non-reified type parameter under ::class should be rejected by type checker: " + type; + putReifiedOperationMarkerIfTypeIsReifiedParameter(type, ReifiedTypeInliner.OperationKind.JAVA_CLASS); + } + + putJavaLangClassInstance(v, typeMapper.mapType(type)); + } + + if (wrapIntoKClass) { + wrapJavaClassIntoKClass(v); + } + + return Unit.INSTANCE; }); } @@ -3551,24 +3485,21 @@ public class ExpressionCodegen extends KtVisitor impleme assert deparenthesized != null : "For with empty range expression"; boolean isInverted = operationReference.getReferencedNameElementType() == KtTokens.NOT_IN; - return StackValue.operation(Type.BOOLEAN_TYPE, new Function1() { - @Override - public Unit invoke(InstructionAdapter v) { - if (RangeCodegenUtil.isPrimitiveRangeSpecializationOfType(leftValue.type, deparenthesized, bindingContext) || - RangeCodegenUtil.isPrimitiveRangeToExtension(operationReference, bindingContext)) { - generateInPrimitiveRange(leftValue, (KtBinaryExpression) deparenthesized, isInverted); - } - else { - ResolvedCall resolvedCall = CallUtilKt - .getResolvedCallWithAssert(operationReference, bindingContext); - StackValue result = invokeFunction(resolvedCall.getCall(), resolvedCall, StackValue.none()); - result.put(result.type, v); - if (isInverted) { - genInvertBoolean(v); - } - } - return null; + return StackValue.operation(Type.BOOLEAN_TYPE, v -> { + if (RangeCodegenUtil.isPrimitiveRangeSpecializationOfType(leftValue.type, deparenthesized, bindingContext) || + RangeCodegenUtil.isPrimitiveRangeToExtension(operationReference, bindingContext)) { + generateInPrimitiveRange(leftValue, (KtBinaryExpression) deparenthesized, isInverted); } + else { + ResolvedCall resolvedCall = CallUtilKt + .getResolvedCallWithAssert(operationReference, bindingContext); + StackValue result = invokeFunction(resolvedCall.getCall(), resolvedCall, StackValue.none()); + result.put(result.type, v); + if (isInverted) { + genInvertBoolean(v); + } + } + return null; }); } @@ -3682,21 +3613,15 @@ public class ExpressionCodegen extends KtVisitor impleme //check nullability cause there is some optimizations in codegen for non-nullable case if (left754Type.isNullable || right754Type.isNullable) { if (state.getLanguageVersionSettings().getApiVersion().compareTo(ApiVersion.KOTLIN_1_1) >= 0) { - return StackValue.operation(Type.BOOLEAN_TYPE, new Function1() { - @Override - public Unit invoke(InstructionAdapter v) { - generate754EqualsForNullableTypesViaIntrinsic(v, opToken, pregeneratedLeft, left, left754Type, right, right754Type); - return Unit.INSTANCE; - } + return StackValue.operation(Type.BOOLEAN_TYPE, v -> { + generate754EqualsForNullableTypesViaIntrinsic(v, opToken, pregeneratedLeft, left, left754Type, right, right754Type); + return Unit.INSTANCE; }); } else { - return StackValue.operation(Type.BOOLEAN_TYPE, new Function1() { - @Override - public Unit invoke(InstructionAdapter v) { - generate754EqualsForNullableTypes(v, opToken, pregeneratedLeft, left, left754Type, right, right754Type); - return Unit.INSTANCE; - } + return StackValue.operation(Type.BOOLEAN_TYPE, v -> { + generate754EqualsForNullableTypes(v, opToken, pregeneratedLeft, left, left754Type, right, right754Type); + return Unit.INSTANCE; }); } } @@ -3861,24 +3786,21 @@ public class ExpressionCodegen extends KtVisitor impleme return value; } - return StackValue.operation(exprType, new Function1() { - @Override - public Unit invoke(InstructionAdapter v) { - value.put(value.type, v); - v.dup(); + return StackValue.operation(exprType, v -> { + value.put(value.type, v); + v.dup(); - v.ifnull(ifNull); - StackValue.onStack(leftType).put(exprType, v); + v.ifnull(ifNull); + StackValue.onStack(leftType).put(exprType, v); - Label end = new Label(); - v.goTo(end); + Label end = new Label(); + v.goTo(end); - v.mark(ifNull); - v.pop(); - gen(expression.getRight(), exprType); - v.mark(end); - return null; - } + v.mark(ifNull); + v.pop(); + gen(expression.getRight(), exprType); + v.mark(end); + return null; }); } @@ -3915,36 +3837,30 @@ public class ExpressionCodegen extends KtVisitor impleme } private StackValue generateAssignmentExpression(KtBinaryExpression expression) { - return StackValue.operation(Type.VOID_TYPE, new Function1() { - @Override - public Unit invoke(InstructionAdapter adapter) { - StackValue stackValue = gen(expression.getLeft()); - KtExpression right = expression.getRight(); - assert right != null : expression.getText(); - stackValue.store(gen(right), v); + return StackValue.operation(Type.VOID_TYPE, adapter -> { + StackValue stackValue = gen(expression.getLeft()); + KtExpression right = expression.getRight(); + assert right != null : expression.getText(); + stackValue.store(gen(right), v); - return Unit.INSTANCE; - } + return Unit.INSTANCE; }); } private StackValue generateAugmentedAssignment(KtBinaryExpression expression) { - return StackValue.operation(Type.VOID_TYPE, new Function1() { - @Override - public Unit invoke(InstructionAdapter adapter) { - ResolvedCall resolvedCall = CallUtilKt.getResolvedCallWithAssert(expression, bindingContext); - FunctionDescriptor descriptor = accessibleFunctionDescriptor(resolvedCall); - Callable callable = resolveToCallable(descriptor, false, resolvedCall); - KtExpression lhs = expression.getLeft(); - Type lhsType = expressionType(lhs); + return StackValue.operation(Type.VOID_TYPE, adapter -> { + ResolvedCall resolvedCall = CallUtilKt.getResolvedCallWithAssert(expression, bindingContext); + FunctionDescriptor descriptor = accessibleFunctionDescriptor(resolvedCall); + Callable callable = resolveToCallable(descriptor, false, resolvedCall); + KtExpression lhs = expression.getLeft(); + Type lhsType = expressionType(lhs); - boolean keepReturnValue = Boolean.TRUE.equals(bindingContext.get(VARIABLE_REASSIGNMENT, expression)) - || !KotlinBuiltIns.isUnit(descriptor.getReturnType()); + boolean keepReturnValue = Boolean.TRUE.equals(bindingContext.get(VARIABLE_REASSIGNMENT, expression)) + || !KotlinBuiltIns.isUnit(descriptor.getReturnType()); - putCallAugAssignMethod(expression, resolvedCall, callable, lhsType, keepReturnValue); + putCallAugAssignMethod(expression, resolvedCall, callable, lhsType, keepReturnValue); - return Unit.INSTANCE; - } + return Unit.INSTANCE; }); } @@ -4038,22 +3954,17 @@ public class ExpressionCodegen extends KtVisitor impleme public StackValue visitPostfixExpression(@NotNull KtPostfixExpression expression, StackValue receiver) { if (expression.getOperationReference().getReferencedNameElementType() == KtTokens.EXCLEXCL) { StackValue base = genQualified(receiver, expression.getBaseExpression()); - if (isPrimitive(base.type)) { - return base; - } else { - return StackValue.operation(base.type, new Function1() { - @Override - public Unit invoke(InstructionAdapter v) { - base.put(base.type, v); - v.dup(); - Label ok = new Label(); - v.ifnonnull(ok); - v.invokestatic(IntrinsicMethods.INTRINSICS_CLASS_NAME, "throwNpe", "()V", false); - v.mark(ok); - return null; - } - }); - } + if (isPrimitive(base.type)) return base; + + return StackValue.operation(base.type, v -> { + base.put(base.type, v); + v.dup(); + Label ok = new Label(); + v.ifnonnull(ok); + v.invokestatic(IntrinsicMethods.INTRINSICS_CLASS_NAME, "throwNpe", "()V", false); + v.mark(ok); + return null; + }); } DeclarationDescriptor originalOperation = bindingContext.get(REFERENCE_TARGET, expression.getOperationReference()); @@ -4094,36 +4005,33 @@ public class ExpressionCodegen extends KtVisitor impleme } } - return StackValue.operation(asmBaseType, new Function1() { - @Override - public Unit invoke(InstructionAdapter v) { - StackValue value = StackValue.complexWriteReadReceiver(gen(expression.getBaseExpression())); + return StackValue.operation(asmBaseType, v -> { + StackValue value = StackValue.complexWriteReadReceiver(gen(expression.getBaseExpression())); - value.put(asmBaseType, v); - AsmUtil.dup(v, asmBaseType); + value.put(asmBaseType, v); + AsmUtil.dup(v, asmBaseType); - StackValue previousValue = StackValue.local(myFrameMap.enterTemp(asmBaseType), asmBaseType); - previousValue.store(StackValue.onStack(asmBaseType), v); + StackValue previousValue = StackValue.local(myFrameMap.enterTemp(asmBaseType), asmBaseType); + previousValue.store(StackValue.onStack(asmBaseType), v); - Type storeType; - if (isPrimitiveNumberClassDescriptor && AsmUtil.isPrimitive(asmBaseType)) { - genIncrement(asmBaseType, increment, v); - storeType = asmBaseType; - } - else { - StackValue result = invokeFunction(resolvedCall, StackValue.onStack(asmBaseType)); - result.put(result.type, v); - storeType = result.type; - } - - value.store(StackValue.onStack(storeType), v, true); - - previousValue.put(asmBaseType, v); - - myFrameMap.leaveTemp(asmBaseType); - - return Unit.INSTANCE; + Type storeType; + if (isPrimitiveNumberClassDescriptor && AsmUtil.isPrimitive(asmBaseType)) { + genIncrement(asmBaseType, increment, v); + storeType = asmBaseType; } + else { + StackValue result = invokeFunction(resolvedCall, StackValue.onStack(asmBaseType)); + result.put(result.type, v); + storeType = result.type; + } + + value.store(StackValue.onStack(storeType), v, true); + + previousValue.put(asmBaseType, v); + + myFrameMap.leaveTemp(asmBaseType); + + return Unit.INSTANCE; }); } @@ -4337,35 +4245,32 @@ public class ExpressionCodegen extends KtVisitor impleme @NotNull public StackValue generateConstructorCall(@NotNull ResolvedCall resolvedCall, @NotNull Type objectType) { - return StackValue.functionCall(objectType, new Function1() { - @Override - public Unit invoke(InstructionAdapter v) { - v.anew(objectType); - v.dup(); + return StackValue.functionCall(objectType, v -> { + v.anew(objectType); + v.dup(); - ClassConstructorDescriptor constructor = getConstructorDescriptor(resolvedCall); + ClassConstructorDescriptor constructor = getConstructorDescriptor(resolvedCall); - ReceiverParameterDescriptor dispatchReceiver = constructor.getDispatchReceiverParameter(); - ClassDescriptor containingDeclaration = constructor.getContainingDeclaration(); - if (dispatchReceiver != null) { - Type receiverType = typeMapper.mapType(dispatchReceiver.getType()); - ReceiverValue receiver = getConstructorReceiver(resolvedCall); - boolean callSuper = containingDeclaration.isInner() && receiver instanceof ImplicitClassReceiver; - generateReceiverValue(receiver, callSuper).put(receiverType, v); - } - - // Resolved call to local class constructor doesn't have dispatchReceiver, so we need to generate closure on stack - // See StackValue.receiver for more info - pushClosureOnStack( - containingDeclaration, dispatchReceiver == null, defaultCallGenerator, /* functionReferenceReceiver = */ null - ); - - constructor = SamCodegenUtil.resolveSamAdapter(constructor); - CallableMethod method = typeMapper.mapToCallableMethod(constructor, false); - invokeMethodWithArguments(method, resolvedCall, StackValue.none()); - - return Unit.INSTANCE; + ReceiverParameterDescriptor dispatchReceiver = constructor.getDispatchReceiverParameter(); + ClassDescriptor containingDeclaration = constructor.getContainingDeclaration(); + if (dispatchReceiver != null) { + Type receiverType = typeMapper.mapType(dispatchReceiver.getType()); + ReceiverValue receiver = getConstructorReceiver(resolvedCall); + boolean callSuper = containingDeclaration.isInner() && receiver instanceof ImplicitClassReceiver; + generateReceiverValue(receiver, callSuper).put(receiverType, v); } + + // Resolved call to local class constructor doesn't have dispatchReceiver, so we need to generate closure on stack + // See StackValue.receiver for more info + pushClosureOnStack( + containingDeclaration, dispatchReceiver == null, defaultCallGenerator, /* functionReferenceReceiver = */ null + ); + + constructor = SamCodegenUtil.resolveSamAdapter(constructor); + CallableMethod method = typeMapper.mapToCallableMethod(constructor, false); + invokeMethodWithArguments(method, resolvedCall, StackValue.none()); + + return Unit.INSTANCE; }); } @@ -4377,13 +4282,10 @@ public class ExpressionCodegen extends KtVisitor impleme if (args.size() == 1) { KtExpression sizeExpression = args.get(0).getArgumentExpression(); - return StackValue.operation(typeMapper.mapType(arrayType), new Function1() { - @Override - public Unit invoke(InstructionAdapter v) { - gen(sizeExpression, Type.INT_TYPE); - newArrayInstruction(arrayType); - return Unit.INSTANCE; - } + return StackValue.operation(typeMapper.mapType(arrayType), v -> { + gen(sizeExpression, Type.INT_TYPE); + newArrayInstruction(arrayType); + return Unit.INSTANCE; }); } @@ -4478,13 +4380,10 @@ public class ExpressionCodegen extends KtVisitor impleme @Override public StackValue visitThrowExpression(@NotNull KtThrowExpression expression, StackValue receiver) { - return StackValue.operation(Type.VOID_TYPE, new Function1() { - @Override - public Unit invoke(InstructionAdapter adapter) { - gen(expression.getThrownExpression(), JAVA_THROWABLE_TYPE); - v.athrow(); - return Unit.INSTANCE; - } + return StackValue.operation(Type.VOID_TYPE, adapter -> { + gen(expression.getThrownExpression(), JAVA_THROWABLE_TYPE); + v.athrow(); + return Unit.INSTANCE; }); } @@ -4514,120 +4413,117 @@ The "returned" value of try expression with no finally is either the last expres Type expectedAsmType = isStatement ? Type.VOID_TYPE : expressionTypeForBranchingOperation(expression); - return StackValue.operation(expectedAsmType, new Function1() { - @Override - public Unit invoke(InstructionAdapter v) { - KtFinallySection finallyBlock = expression.getFinallyBlock(); - FinallyBlockStackElement finallyBlockStackElement = null; - if (finallyBlock != null) { - finallyBlockStackElement = new FinallyBlockStackElement(expression); - blockStackElements.push(finallyBlockStackElement); + return StackValue.operation(expectedAsmType, v -> { + KtFinallySection finallyBlock = expression.getFinallyBlock(); + FinallyBlockStackElement finallyBlockStackElement = null; + if (finallyBlock != null) { + finallyBlockStackElement = new FinallyBlockStackElement(expression); + blockStackElements.push(finallyBlockStackElement); + } + + //PseudoInsnsPackage.saveStackBeforeTryExpr(v); + + Label tryStart = new Label(); + v.mark(tryStart); + v.nop(); // prevent verify error on empty try + + gen(expression.getTryBlock(), expectedAsmType); + + int savedValue = -1; + if (!isStatement) { + savedValue = myFrameMap.enterTemp(expectedAsmType); + v.store(savedValue, expectedAsmType); + } + + Label tryEnd = new Label(); + v.mark(tryEnd); + + //do it before finally block generation + List