@Override public StackValue generate( ExpressionCodegen codegen, InstructionAdapter v, @NotNull Type expectedType, @Nullable PsiElement element, @Nullable List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) { JetCallExpression call = (JetCallExpression) element; ResolvedCall<? extends CallableDescriptor> resolvedCall = codegen.getBindingContext().get(BindingContext.RESOLVED_CALL, call.getCalleeExpression()); CallableDescriptor resultingDescriptor = resolvedCall.getResultingDescriptor(); Type type = state .getInjector() .getJetTypeMapper() .mapType( resultingDescriptor.getReturnType().getArguments().get(0).getType(), MapTypeMode.VALUE); JvmPrimitiveType primitiveType = JvmPrimitiveType.getByAsmType(type); if (primitiveType != null) { v.getstatic( primitiveType.getWrapper().getAsmType().getInternalName(), "TYPE", "Ljava/lang/Class;"); } else { v.aconst(type); } return StackValue.onStack(JetTypeMapper.JL_CLASS_TYPE); }
@Override public StackValue generate( ExpressionCodegen codegen, InstructionAdapter v, @NotNull Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) { if (arguments.size() == 1) { final Type leftType = receiver.type; final Type rightType = codegen.expressionType(arguments.get(0)); receiver.put(Type.INT_TYPE, v); codegen.gen(arguments.get(0), rightType); v.invokestatic( "jet/runtime/Ranges", forward ? "upTo" : "downTo", "(" + receiver.type.getDescriptor() + leftType.getDescriptor() + ")" + expectedType.getDescriptor()); return StackValue.onStack(expectedType); } else { JetBinaryExpression expression = (JetBinaryExpression) element; final Type leftType = codegen.expressionType(expression.getLeft()); final Type rightType = codegen.expressionType(expression.getRight()); // if (JetTypeMapper.isIntPrimitive(leftType)) { codegen.gen(expression.getLeft(), leftType); codegen.gen(expression.getRight(), rightType); v.invokestatic( "jet/runtime/Ranges", forward ? "upTo" : "downTo", "(" + leftType.getDescriptor() + rightType.getDescriptor() + ")" + expectedType.getDescriptor()); return StackValue.onStack(expectedType); // } // else { // throw new UnsupportedOperationException("ranges are only supported for int // objects"); // } } }
@Override public StackValue generate( ExpressionCodegen codegen, InstructionAdapter v, @NotNull Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) { receiver.put(AsmTypeConstants.OBJECT_TYPE, v); JetCallExpression call = (JetCallExpression) element; FunctionDescriptor funDescriptor = (FunctionDescriptor) codegen .getBindingContext() .get( BindingContext.REFERENCE_TARGET, (JetSimpleNameExpression) call.getCalleeExpression()); assert funDescriptor != null; ClassDescriptor containingDeclaration = (ClassDescriptor) funDescriptor.getContainingDeclaration().getOriginal(); if (containingDeclaration.equals(JetStandardLibrary.getInstance().getArray())) { v.invokestatic( "jet/runtime/ArrayIterator", "iterator", "([Ljava/lang/Object;)Ljava/util/Iterator;"); return StackValue.onStack(AsmTypeConstants.JET_ITERATOR_TYPE); } else { for (JvmPrimitiveType jvmPrimitiveType : JvmPrimitiveType.values()) { PrimitiveType primitiveType = jvmPrimitiveType.getPrimitiveType(); if (primitiveType.getArrayClassName().is(containingDeclaration)) { String methodSignature = "([" + jvmPrimitiveType.getJvmLetter() + ")" + jvmPrimitiveType.getIterator().getDescriptor(); v.invokestatic("jet/runtime/ArrayIterator", "iterator", methodSignature); return StackValue.onStack(jvmPrimitiveType.getIterator().getAsmType()); } } throw new UnsupportedOperationException(containingDeclaration.toString()); } }
@Override public StackValue generate( ExpressionCodegen codegen, InstructionAdapter v, @NotNull Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) { final CallableMethod callableMethod = state.getTypeMapper().mapToCallableMethod(method, false, OwnerKind.IMPLEMENTATION); codegen.invokeMethodWithArguments(callableMethod, (JetCallExpression) element, receiver); return StackValue.onStack(callableMethod.getSignature().getAsmMethod().getReturnType()); }
@Override public StackValue generate( ExpressionCodegen codegen, InstructionAdapter v, @NotNull Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) { receiver.put(JetTypeMapper.TYPE_OBJECT, v); v.arraylength(); v.invokestatic("jet/IntRange", "count", "(I)Ljet/IntRange;"); return StackValue.onStack(JetTypeMapper.TYPE_INT_RANGE); }
@Override public StackValue generate( ExpressionCodegen codegen, InstructionAdapter v, @NotNull Type expectedType, @Nullable PsiElement element, @Nullable List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) { JvmPrimitiveType primitiveType = JvmPrimitiveType.getByAsmType(receiver.type); if (primitiveType != null) { v.getstatic( primitiveType.getWrapper().getAsmType().getInternalName(), "TYPE", "Ljava/lang/Class;"); } else { receiver.put(receiver.type, v); v.invokevirtual("java/lang/Object", "getClass", "()Ljava/lang/Class;"); } return StackValue.onStack(AsmTypeConstants.getType(Class.class)); }
@NotNull @Override public Type generateImpl( @NotNull ExpressionCodegen codegen, @NotNull InstructionAdapter v, @NotNull Type returnType, PsiElement element, List<JetExpression> arguments, StackValue receiver) { StackValue stackValue; if (arguments.size() == 1) { stackValue = codegen.gen(arguments.get(0)); } else { stackValue = receiver; } stackValue.put(Type.BOOLEAN_TYPE, v); StackValue.not(StackValue.onStack(Type.BOOLEAN_TYPE)).put(returnType, v); return returnType; }
@Override public StackValue generate( ExpressionCodegen codegen, InstructionAdapter v, @NotNull Type expectedType, @Nullable PsiElement element, @Nullable List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) { boolean nullable = expectedType.getSort() == Type.OBJECT; if (nullable) { expectedType = JetTypeMapper.unboxType(expectedType); } if (receiver != null && receiver != StackValue.none()) receiver.put(expectedType, v); else { assert arguments != null; codegen.gen(arguments.get(0), expectedType); } return StackValue.onStack(expectedType); }
@Override public StackValue generate( ExpressionCodegen codegen, InstructionAdapter v, @NotNull Type expectedType, PsiElement element, List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state) { boolean nullable = expectedType.getSort() == Type.OBJECT; if (nullable) { expectedType = CodegenUtil.unboxType(expectedType); } receiver.put(expectedType, v); if (expectedType == Type.LONG_TYPE) { v.lconst(-1L); } else { v.iconst(-1); } v.xor(expectedType); return StackValue.onStack(expectedType); }