Examples with Type org.jetbrains.org.objectweb.asm.Type used on opensource projects

Example 21 with Type

use of org.jetbrains.org.objectweb.asm.Type in project kotlin by JetBrains.

the class ImplementationBodyCodegen method generateEnumValuesMethod.

private void generateEnumValuesMethod() {
    Type type = typeMapper.mapType(DescriptorUtilsKt.getBuiltIns(descriptor).getArrayType(INVARIANT, descriptor.getDefaultType()));
    FunctionDescriptor valuesFunction = CollectionsKt.single(descriptor.getStaticScope().getContributedFunctions(ENUM_VALUES, NoLookupLocation.FROM_BACKEND));
    MethodVisitor mv = v.newMethod(JvmDeclarationOriginKt.OtherOrigin(myClass, valuesFunction), ACC_PUBLIC | ACC_STATIC, ENUM_VALUES.asString(), "()" + type.getDescriptor(), null, null);
    if (!state.getClassBuilderMode().generateBodies)
        return;
    mv.visitCode();
    mv.visitFieldInsn(GETSTATIC, classAsmType.getInternalName(), ENUM_VALUES_FIELD_NAME, type.getDescriptor());
    mv.visitMethodInsn(INVOKEVIRTUAL, type.getInternalName(), "clone", "()Ljava/lang/Object;", false);
    mv.visitTypeInsn(CHECKCAST, type.getInternalName());
    mv.visitInsn(ARETURN);
    FunctionCodegen.endVisit(mv, "values()", myClass);
}

Example 22 with Type

use of org.jetbrains.org.objectweb.asm.Type in project kotlin by JetBrains.

the class ImplementationBodyCodegen method initializeEnumConstants.

private void initializeEnumConstants(@NotNull List<KtEnumEntry> enumEntries) {
    if (!state.getClassBuilderMode().generateBodies)
        return;
    ExpressionCodegen codegen = createOrGetClInitCodegen();
    InstructionAdapter iv = codegen.v;
    Type arrayAsmType = typeMapper.mapType(DescriptorUtilsKt.getBuiltIns(descriptor).getArrayType(INVARIANT, descriptor.getDefaultType()));
    v.newField(JvmDeclarationOriginKt.OtherOrigin(myClass), ACC_PRIVATE | ACC_STATIC | ACC_FINAL | ACC_SYNTHETIC, ENUM_VALUES_FIELD_NAME, arrayAsmType.getDescriptor(), null, null);
    iv.iconst(enumEntries.size());
    iv.newarray(classAsmType);
    if (!enumEntries.isEmpty()) {
        iv.dup();
        for (int ordinal = 0, size = enumEntries.size(); ordinal < size; ordinal++) {
            initializeEnumConstant(enumEntries, ordinal);
        }
    }
    iv.putstatic(classAsmType.getInternalName(), ENUM_VALUES_FIELD_NAME, arrayAsmType.getDescriptor());
}

Example 23 with Type

use of org.jetbrains.org.objectweb.asm.Type in project kotlin by JetBrains.

the class FunctionReferenceGenerationStrategy method doGenerateBody.

@Override
public void doGenerateBody(@NotNull ExpressionCodegen codegen, @NotNull JvmMethodSignature signature) {
    /*
         Here we need to put the arguments from our locals to the stack and invoke the referenced method. Since invocation
         of methods is highly dependent on expressions, we create a fake call expression. Then we create a new instance of
         ExpressionCodegen and, in order for it to generate code correctly, we save to its 'tempVariables' field every
         argument of our fake expression, pointing it to the corresponding index in our locals. This way generation of
         every argument boils down to calling LOAD with the corresponding index
         */
    KtCallExpression fakeExpression = CodegenUtil.constructFakeFunctionCall(state.getProject(), referencedFunction);
    final List<? extends ValueArgument> fakeArguments = fakeExpression.getValueArguments();
    final ReceiverValue dispatchReceiver = computeAndSaveReceiver(signature, codegen, referencedFunction.getDispatchReceiverParameter());
    final ReceiverValue extensionReceiver = computeAndSaveReceiver(signature, codegen, referencedFunction.getExtensionReceiverParameter());
    computeAndSaveArguments(fakeArguments, codegen);
    ResolvedCall<CallableDescriptor> fakeResolvedCall = new DelegatingResolvedCall<CallableDescriptor>(resolvedCall) {

        private final Map<ValueParameterDescriptor, ResolvedValueArgument> argumentMap;

        {
            argumentMap = new LinkedHashMap<ValueParameterDescriptor, ResolvedValueArgument>(fakeArguments.size());
            int index = 0;
            List<ValueParameterDescriptor> parameters = functionDescriptor.getValueParameters();
            for (ValueArgument argument : fakeArguments) {
                argumentMap.put(parameters.get(index), new ExpressionValueArgument(argument));
                index++;
            }
        }

        @Nullable
        @Override
        public ReceiverValue getExtensionReceiver() {
            return extensionReceiver;
        }

        @Nullable
        @Override
        public ReceiverValue getDispatchReceiver() {
            return dispatchReceiver;
        }

        @NotNull
        @Override
        public List<ResolvedValueArgument> getValueArgumentsByIndex() {
            return new ArrayList<ResolvedValueArgument>(argumentMap.values());
        }

        @NotNull
        @Override
        public Map<ValueParameterDescriptor, ResolvedValueArgument> getValueArguments() {
            return argumentMap;
        }
    };
    StackValue result;
    Type returnType = codegen.getReturnType();
    if (referencedFunction instanceof ConstructorDescriptor) {
        if (returnType.getSort() == Type.ARRAY) {
            //noinspection ConstantConditions
            result = codegen.generateNewArray(fakeExpression, referencedFunction.getReturnType(), fakeResolvedCall);
        } else {
            result = codegen.generateConstructorCall(fakeResolvedCall, returnType);
        }
    } else {
        Call call = CallMaker.makeCall(fakeExpression, null, null, fakeExpression, fakeArguments);
        result = codegen.invokeFunction(call, fakeResolvedCall, StackValue.none());
    }
    InstructionAdapter v = codegen.v;
    result.put(returnType, v);
    v.areturn(returnType);
}

Example 24 with Type

use of org.jetbrains.org.objectweb.asm.Type in project kotlin by JetBrains.

the class FunctionReferenceGenerationStrategy method receiverParameterStackValue.

@NotNull
private StackValue receiverParameterStackValue(@NotNull JvmMethodSignature signature, @NotNull ExpressionCodegen codegen) {
    if (receiverValue != null)
        return receiverValue;
    if (receiverType != null) {
        ClassDescriptor classDescriptor = (ClassDescriptor) codegen.getContext().getParentContext().getContextDescriptor();
        Type asmType = codegen.getState().getTypeMapper().mapClass(classDescriptor);
        return CallableReferenceUtilKt.capturedBoundReferenceReceiver(asmType, receiverType, isInliningStrategy);
    }
    // 0 is this (the callable reference class), 1 is the invoke() method's first parameter
    return StackValue.local(1, signature.getAsmMethod().getArgumentTypes()[0]);
}

Example 25 with Type

use of org.jetbrains.org.objectweb.asm.Type in project kotlin by JetBrains.

the class PackageCodegenImpl method generateFile.

private void generateFile(@NotNull KtFile file) {
    JvmFileClassInfo fileClassInfo = state.getFileClassesProvider().getFileClassInfo(file);
    if (fileClassInfo.getWithJvmMultifileClass()) {
        return;
    }
    Type fileClassType = AsmUtil.asmTypeByFqNameWithoutInnerClasses(fileClassInfo.getFileClassFqName());
    PackageContext packagePartContext = state.getRootContext().intoPackagePart(packageFragment, fileClassType, file);
    boolean generatePackagePart = false;
    List<KtClassOrObject> classOrObjects = new ArrayList<KtClassOrObject>();
    for (KtDeclaration declaration : file.getDeclarations()) {
        if (declaration.hasModifier(KtTokens.HEADER_KEYWORD))
            continue;
        if (declaration instanceof KtProperty || declaration instanceof KtNamedFunction || declaration instanceof KtTypeAlias) {
            generatePackagePart = true;
        } else if (declaration instanceof KtClassOrObject) {
            KtClassOrObject classOrObject = (KtClassOrObject) declaration;
            if (state.getGenerateDeclaredClassFilter().shouldGenerateClass(classOrObject)) {
                classOrObjects.add(classOrObject);
            }
        } else if (declaration instanceof KtScript) {
            KtScript script = (KtScript) declaration;
            if (state.getGenerateDeclaredClassFilter().shouldGenerateScript(script)) {
                ScriptCodegen.createScriptCodegen(script, state, packagePartContext).generate();
            }
        }
    }
    generateClassesAndObjectsInFile(classOrObjects, packagePartContext);
    if (!generatePackagePart || !state.getGenerateDeclaredClassFilter().shouldGeneratePackagePart(file))
        return;
    String name = fileClassType.getInternalName();
    packagePartRegistry.addPart(StringsKt.substringAfterLast(name, '/', name), null);
    ClassBuilder builder = state.getFactory().newVisitor(JvmDeclarationOriginKt.PackagePart(file, packageFragment), fileClassType, file);
    new PackagePartCodegen(builder, file, fileClassType, packagePartContext, state).generate();
}