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

Example 81 with Type

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

the class ExpressionCodegen method genSamInterfaceValue.

@Nullable
private StackValue genSamInterfaceValue(@NotNull KtExpression probablyParenthesizedExpression, @NotNull final KtVisitor<StackValue, StackValue> visitor) {
    final KtExpression expression = KtPsiUtil.deparenthesize(probablyParenthesizedExpression);
    final SamType samType = bindingContext.get(SAM_VALUE, probablyParenthesizedExpression);
    if (samType == null || expression == null)
        return null;
    if (expression instanceof KtLambdaExpression) {
        return genClosure(((KtLambdaExpression) expression).getFunctionLiteral(), samType);
    }
    if (expression instanceof KtNamedFunction) {
        return genClosure((KtNamedFunction) expression, samType);
    }
    final Type asmType = state.getSamWrapperClasses().getSamWrapperClass(samType, expression.getContainingKtFile(), this);
    return StackValue.operation(asmType, new Function1<InstructionAdapter, Unit>() {

        @Override
        public Unit invoke(InstructionAdapter v) {
            v.anew(asmType);
            v.dup();
            Type functionType = typeMapper.mapType(samType.getKotlinFunctionType());
            expression.accept(visitor, StackValue.none()).put(functionType, v);
            Label ifNonNull = new Label();
            Label afterAll = new Label();
            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);
            v.mark(ifNonNull);
            v.invokespecial(asmType.getInternalName(), "<init>", Type.getMethodDescriptor(Type.VOID_TYPE, functionType), false);
            v.mark(afterAll);
            return null;
        }
    });
}

Example 82 with Type

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

the class ExpressionCodegen method generate754EqualsForNullableTypes.

private void generate754EqualsForNullableTypes(@NotNull InstructionAdapter v, @NotNull IElementType opToken, @Nullable StackValue pregeneratedLeft, @Nullable KtExpression left, @NotNull TypeAndNullability left754Type, @Nullable KtExpression right, @NotNull TypeAndNullability right754Type) {
    int equals = opToken == KtTokens.EQEQ ? 1 : 0;
    int notEquals = opToken != KtTokens.EQEQ ? 1 : 0;
    Label end = new Label();
    StackValue leftValue = pregeneratedLeft != null ? pregeneratedLeft : gen(left);
    leftValue.put(leftValue.type, v);
    leftValue = StackValue.onStack(leftValue.type);
    Type leftType = left754Type.type;
    Type rightType = right754Type.type;
    if (left754Type.isNullable) {
        leftValue.dup(v, false);
        Label leftIsNull = new Label();
        v.ifnull(leftIsNull);
        StackValue.coercion(leftValue, leftType).put(leftType, v);
        StackValue nonNullLeftValue = StackValue.onStack(leftType);
        StackValue rightValue = gen(right);
        rightValue.put(rightValue.type, v);
        rightValue = StackValue.onStack(rightValue.type);
        if (right754Type.isNullable) {
            rightValue.dup(v, false);
            Label rightIsNotNull = new Label();
            v.ifnonnull(rightIsNotNull);
            AsmUtil.pop(v, rightValue.type);
            AsmUtil.pop(v, nonNullLeftValue.type);
            v.iconst(notEquals);
            v.goTo(end);
            v.mark(rightIsNotNull);
        }
        StackValue.coercion(rightValue, rightType).put(rightType, v);
        StackValue nonNullRightValue = StackValue.onStack(rightType);
        StackValue.cmp(opToken, leftType, nonNullLeftValue, nonNullRightValue).put(Type.BOOLEAN_TYPE, v);
        v.goTo(end);
        //left is null case
        v.mark(leftIsNull);
        //pop null left
        AsmUtil.pop(v, leftValue.type);
        rightValue = gen(right);
        rightValue.put(rightValue.type, v);
        rightValue = StackValue.onStack(rightValue.type);
        if (right754Type.isNullable) {
            Label rightIsNotNull = new Label();
            v.ifnonnull(rightIsNotNull);
            v.iconst(equals);
            v.goTo(end);
            v.mark(rightIsNotNull);
            v.iconst(notEquals);
        //v.goTo(end);
        } else {
            AsmUtil.pop(v, rightValue.type);
            v.iconst(notEquals);
        //v.goTo(end);
        }
        v.mark(end);
        return;
    } else {
        StackValue.coercion(leftValue, leftType).put(leftType, v);
        leftValue = StackValue.onStack(leftType);
    }
    //right is nullable cause left is not
    StackValue rightValue = gen(right);
    rightValue.put(rightValue.type, v);
    rightValue = StackValue.onStack(rightValue.type);
    rightValue.dup(v, false);
    Label rightIsNotNull = new Label();
    v.ifnonnull(rightIsNotNull);
    AsmUtil.pop(v, rightValue.type);
    AsmUtil.pop(v, leftValue.type);
    v.iconst(notEquals);
    v.goTo(end);
    v.mark(rightIsNotNull);
    StackValue.coercion(rightValue, rightType).put(rightType, v);
    StackValue nonNullRightValue = StackValue.onStack(rightType);
    StackValue.cmp(opToken, leftType, leftValue, nonNullRightValue).put(Type.BOOLEAN_TYPE, v);
    v.mark(end);
}

Example 83 with Type

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

the class ExpressionCodegen method visitSafeQualifiedExpression.

@Override
public StackValue visitSafeQualifiedExpression(@NotNull KtSafeQualifiedExpression expression, StackValue unused) {
    Label ifnull = new Label();
    Type type = boxType(expressionType(expression));
    StackValue value = generateSafeQualifiedExpression(expression, ifnull);
    StackValue newReceiver = StackValue.coercion(value, type);
    StackValue result;
    if (!isPrimitive(expressionType(expression.getReceiverExpression()))) {
        result = new StackValue.SafeFallback(type, ifnull, newReceiver);
    } else {
        result = newReceiver;
    }
    return result;
}

Example 84 with Type

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

the class PropertyCodegen method invokeDelegatedPropertyConventionMethodWithReceiver.

public static StackValue invokeDelegatedPropertyConventionMethodWithReceiver(@NotNull ExpressionCodegen codegen, @NotNull KotlinTypeMapper typeMapper, @NotNull ResolvedCall<FunctionDescriptor> resolvedCall, final int indexInPropertyMetadataArray, int propertyMetadataArgumentIndex, @Nullable StackValue receiver, @NotNull PropertyDescriptor propertyDescriptor) {
    final Type owner = JvmAbi.isPropertyWithBackingFieldInOuterClass(propertyDescriptor) ? codegen.getState().getTypeMapper().mapOwner(propertyDescriptor) : getDelegatedPropertyMetadataOwner(codegen, typeMapper);
    codegen.tempVariables.put(resolvedCall.getCall().getValueArguments().get(propertyMetadataArgumentIndex).asElement(), new StackValue(K_PROPERTY_TYPE) {

        @Override
        public void putSelector(@NotNull Type type, @NotNull InstructionAdapter v) {
            Field array = StackValue.field(Type.getType("[" + K_PROPERTY_TYPE), owner, JvmAbi.DELEGATED_PROPERTIES_ARRAY_NAME, true, StackValue.none());
            StackValue.arrayElement(K_PROPERTY_TYPE, array, StackValue.constant(indexInPropertyMetadataArray, Type.INT_TYPE)).put(type, v);
        }
    });
    return codegen.invokeFunction(resolvedCall, receiver);
}

Example 85 with Type

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

the class PropertyCodegen method generateBackingField.

private void generateBackingField(KtNamedDeclaration element, PropertyDescriptor propertyDescriptor, boolean isDelegate, KotlinType kotlinType, Object defaultValue, Annotations annotations) {
    int modifiers = getDeprecatedAccessFlag(propertyDescriptor);
    for (AnnotationCodegen.JvmFlagAnnotation flagAnnotation : AnnotationCodegen.FIELD_FLAGS) {
        if (flagAnnotation.hasAnnotation(propertyDescriptor.getOriginal())) {
            modifiers |= flagAnnotation.getJvmFlag();
        }
    }
    if (kind == OwnerKind.PACKAGE) {
        modifiers |= ACC_STATIC;
    }
    if (!propertyDescriptor.isLateInit() && (!propertyDescriptor.isVar() || isDelegate)) {
        modifiers |= ACC_FINAL;
    }
    if (AnnotationUtilKt.hasJvmSyntheticAnnotation(propertyDescriptor)) {
        modifiers |= ACC_SYNTHETIC;
    }
    Type type = typeMapper.mapType(kotlinType);
    ClassBuilder builder = v;
    FieldOwnerContext backingFieldContext = context;
    if (AsmUtil.isInstancePropertyWithStaticBackingField(propertyDescriptor)) {
        modifiers |= ACC_STATIC;
        if (JvmAbi.isPropertyWithBackingFieldInOuterClass(propertyDescriptor)) {
            ImplementationBodyCodegen codegen = (ImplementationBodyCodegen) memberCodegen.getParentCodegen();
            builder = codegen.v;
            backingFieldContext = codegen.context;
        }
    }
    modifiers |= getVisibilityForBackingField(propertyDescriptor, isDelegate);
    if (AsmUtil.isPropertyWithBackingFieldCopyInOuterClass(propertyDescriptor)) {
        ImplementationBodyCodegen parentBodyCodegen = (ImplementationBodyCodegen) memberCodegen.getParentCodegen();
        parentBodyCodegen.addCompanionObjectPropertyToCopy(propertyDescriptor, defaultValue);
    }
    String name = backingFieldContext.getFieldName(propertyDescriptor, isDelegate);
    v.getSerializationBindings().put(FIELD_FOR_PROPERTY, propertyDescriptor, Pair.create(type, name));
    FieldVisitor fv = builder.newField(JvmDeclarationOriginKt.OtherOrigin(element, propertyDescriptor), modifiers, name, type.getDescriptor(), isDelegate ? null : typeMapper.mapFieldSignature(kotlinType, propertyDescriptor), defaultValue);
    Annotated fieldAnnotated = new AnnotatedWithFakeAnnotations(propertyDescriptor, annotations);
    AnnotationCodegen.forField(fv, memberCodegen, typeMapper).genAnnotations(fieldAnnotated, type, isDelegate ? AnnotationUseSiteTarget.PROPERTY_DELEGATE_FIELD : AnnotationUseSiteTarget.FIELD);
}