Beispiel #1
0
  @NotNull
  protected ExpressionCodegen createOrGetClInitCodegen() {
    DeclarationDescriptor descriptor = context.getContextDescriptor();
    assert state.getClassBuilderMode() == ClassBuilderMode.FULL
        : "<clinit> should not be generated for light classes. Descriptor: " + descriptor;
    if (clInit == null) {
      MethodVisitor mv = v.newMethod(null, ACC_STATIC, "<clinit>", "()V", null, null);
      mv.visitCode();
      SimpleFunctionDescriptorImpl clInit =
          SimpleFunctionDescriptorImpl.create(
              descriptor, Annotations.EMPTY, Name.special("<clinit>"), SYNTHESIZED);
      clInit.initialize(
          null,
          null,
          Collections.<TypeParameterDescriptor>emptyList(),
          Collections.<ValueParameterDescriptor>emptyList(),
          null,
          null,
          Visibilities.PRIVATE);

      this.clInit =
          new ExpressionCodegen(
              mv, new FrameMap(), Type.VOID_TYPE, context.intoFunction(clInit), state, this);
    }
    return clInit;
  }
Beispiel #2
0
  public void generateDefaultSetter(
      PropertyDescriptor propertyDescriptor, int flags, PsiElement origin) {
    if (propertyDescriptor.getKind() == CallableMemberDescriptor.Kind.FAKE_OVERRIDE) {
      throw new IllegalStateException("must not generate code for fake overrides");
    }

    if (kind == OwnerKind.TRAIT_IMPL) {
      return;
    }

    if (kind == OwnerKind.NAMESPACE) {
      flags |= Opcodes.ACC_STATIC;
    }

    PsiElement psiElement =
        state
            .getBindingContext()
            .get(
                BindingContext.DESCRIPTOR_TO_DECLARATION,
                propertyDescriptor.getContainingDeclaration());
    boolean isTrait = psiElement instanceof JetClass && ((JetClass) psiElement).isTrait();
    if (isTrait && !(kind instanceof OwnerKind.DelegateKind)) flags |= Opcodes.ACC_ABSTRACT;

    if (propertyDescriptor.getModality() == Modality.FINAL) {
      flags |= Opcodes.ACC_FINAL;
    }

    JvmPropertyAccessorSignature signature =
        state.getInjector().getJetTypeMapper().mapSetterSignature(propertyDescriptor, kind);
    final String descriptor = signature.getJvmMethodSignature().getAsmMethod().getDescriptor();
    MethodVisitor mv =
        v.newMethod(
            origin, flags, setterName(propertyDescriptor.getName()), descriptor, null, null);
    generateJetPropertyAnnotation(
        mv,
        signature.getPropertyTypeKotlinSignature(),
        signature.getJvmMethodSignature().getKotlinTypeParameter());

    if (propertyDescriptor.getSetter() != null) {
      assert !propertyDescriptor.getSetter().hasBody();
      AnnotationCodegen.forMethod(mv, state.getInjector().getJetTypeMapper())
          .genAnnotations(propertyDescriptor.getSetter());
    }

    if (v.generateCode() != ClassBuilder.Mode.SIGNATURES
        && (!isTrait || kind instanceof OwnerKind.DelegateKind)) {
      if (propertyDescriptor.getModality() != Modality.ABSTRACT) {
        mv.visitCode();
        if (v.generateCode() == ClassBuilder.Mode.STUBS) {
          StubCodegen.generateStubThrow(mv);
        } else {
          InstructionAdapter iv = new InstructionAdapter(mv);
          final Type type =
              state
                  .getInjector()
                  .getJetTypeMapper()
                  .mapType(propertyDescriptor.getType(), MapTypeMode.VALUE);
          int paramCode = 0;
          if (kind != OwnerKind.NAMESPACE) {
            iv.load(0, JetTypeMapper.TYPE_OBJECT);
            paramCode = 1;
          }

          if ((kind instanceof OwnerKind.DelegateKind)
              != (propertyDescriptor.getKind() == FunctionDescriptor.Kind.DELEGATION)) {
            throw new IllegalStateException("mismatching kind in " + propertyDescriptor);
          }

          if (kind instanceof OwnerKind.DelegateKind) {
            OwnerKind.DelegateKind dk = (OwnerKind.DelegateKind) kind;
            iv.load(0, JetTypeMapper.TYPE_OBJECT);
            dk.getDelegate().put(JetTypeMapper.TYPE_OBJECT, iv);

            iv.load(paramCode, type);
            iv.invokeinterface(
                dk.getOwnerClass(), setterName(propertyDescriptor.getName()), descriptor);
          } else {
            iv.load(paramCode, type);
            iv.visitFieldInsn(
                kind == OwnerKind.NAMESPACE ? Opcodes.PUTSTATIC : Opcodes.PUTFIELD,
                state.getInjector().getJetTypeMapper().getOwner(propertyDescriptor, kind),
                propertyDescriptor.getName(),
                type.getDescriptor());
          }

          iv.visitInsn(Opcodes.RETURN);
        }
      }
      FunctionCodegen.endVisit(mv, "setter", origin);
    }
  }