diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java index 8fcc3ecc98c..c1896c5397a 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java @@ -71,7 +71,6 @@ public class ExpressionCodegen extends JetVisitor { private final Type returnType; private final BindingContext bindingContext; - private final Map typeParameterExpressions = new HashMap(); private final CodegenContext context; private final Stack blockStackElements = new Stack(); @@ -145,10 +144,6 @@ public class ExpressionCodegen extends JetVisitor { return inner; } - public GenerationState getState() { - return state; - } - public BindingContext getBindingContext() { return bindingContext; } @@ -157,10 +152,6 @@ public class ExpressionCodegen extends JetVisitor { return localVariableNames; } - public void addTypeParameter(TypeParameterDescriptor typeParameter, StackValue expression) { - typeParameterExpressions.put(typeParameter, expression); - } - public StackValue genQualified(StackValue receiver, JetElement selector) { if (!(selector instanceof JetBlockExpression)) { markLineNumber(selector); @@ -340,13 +331,13 @@ public class ExpressionCodegen extends JetVisitor { public StackValue visitForExpression(JetForExpression expression, StackValue receiver) { final JetExpression loopRange = expression.getLoopRange(); final JetType expressionType = bindingContext.get(BindingContext.EXPRESSION_TYPE, loopRange); + assert expressionType != null; Type loopRangeType = asmType(expressionType); if (loopRangeType.getSort() == Type.ARRAY) { new ForInArrayLoopGenerator(expression, loopRangeType).invoke(); return StackValue.none(); } else { - assert expressionType != null; final DeclarationDescriptor descriptor = expressionType.getConstructor().getDeclarationDescriptor(); if (isClass(descriptor, "IntRange")) { // TODO IntRange subclasses (now IntRange is final) new ForInRangeLoopGenerator(expression, loopRangeType).invoke(); @@ -530,6 +521,7 @@ public class ExpressionCodegen extends JetVisitor { v.store(myIndexVar, Type.INT_TYPE); } + @Override protected void generateCondition(Type asmParamType, Label end) { Type arrayElParamType; if (JetStandardLibraryNames.ARRAY.is(expressionType)) { @@ -551,10 +543,12 @@ public class ExpressionCodegen extends JetVisitor { v.store(lookupLocal(parameterDescriptor), asmParamType); } + @Override protected void generateIncrement() { v.iinc(myIndexVar, 1); } + @Override protected void cleanupTemp() { myFrameMap.leaveTemp(localArrayVar ? 1 : 2); } @@ -655,6 +649,7 @@ public class ExpressionCodegen extends JetVisitor { } else if (stackElement instanceof LoopBlockStackElement) { LoopBlockStackElement loopBlockStackElement = (LoopBlockStackElement) stackElement; + //noinspection ConstantConditions if (labelElement == null || loopBlockStackElement.targetLabel != null && labelElement.getReferencedName().equals(loopBlockStackElement.targetLabel.getReferencedName())) { @@ -679,10 +674,12 @@ public class ExpressionCodegen extends JetVisitor { if (stackElement instanceof FinallyBlockStackElement) { FinallyBlockStackElement finallyBlockStackElement = (FinallyBlockStackElement) stackElement; JetTryExpression jetTryExpression = finallyBlockStackElement.expression; + //noinspection ConstantConditions gen(jetTryExpression.getFinallyBlock().getFinalExpression(), Type.VOID_TYPE); } else if (stackElement instanceof LoopBlockStackElement) { LoopBlockStackElement loopBlockStackElement = (LoopBlockStackElement) stackElement; + //noinspection ConstantConditions if (labelElement == null || loopBlockStackElement.targetLabel != null && labelElement.getReferencedName().equals(loopBlockStackElement.targetLabel.getReferencedName())) { @@ -870,11 +867,13 @@ public class ExpressionCodegen extends JetVisitor { closureCodegen.superCall .getCalleeExpression() .getConstructorReferenceExpression()); + assert superConstructor != null; CallableMethod superCallable = typeMapper.mapToCallableMethod(superConstructor, OwnerKind.IMPLEMENTATION, typeMapper.hasThis0(superConstructor.getContainingDeclaration())); Type[] argumentTypes = superCallable.getSignature().getAsmMethod().getArgumentTypes(); Collections.addAll(consArgTypes, argumentTypes); ResolvedCall resolvedCall = bindingContext.get(BindingContext.RESOLVED_CALL, closureCodegen.superCall.getCalleeExpression()); + assert resolvedCall != null; pushMethodArguments(resolvedCall, Arrays.asList(argumentTypes)); } @@ -896,7 +895,6 @@ public class ExpressionCodegen extends JetVisitor { } if (statement instanceof JetProperty) { - JetProperty property = (JetProperty) statement; final VariableDescriptor variableDescriptor = bindingContext.get(BindingContext.VARIABLE, statement); assert variableDescriptor != null; @@ -989,6 +987,7 @@ public class ExpressionCodegen extends JetVisitor { FinallyBlockStackElement finallyBlockStackElement = (FinallyBlockStackElement) stackElement; JetTryExpression jetTryExpression = finallyBlockStackElement.expression; blockStackElements.pop(); + //noinspection ConstantConditions gen(jetTryExpression.getFinallyBlock().getFinalExpression(), Type.VOID_TYPE); blockStackElements.push(finallyBlockStackElement); } @@ -1130,8 +1129,6 @@ public class ExpressionCodegen extends JetVisitor { ClassDescriptor propReceiverDescriptor = (ClassDescriptor) propertyDescriptor.getContainingDeclaration(); if (!CodegenUtil.isInterface(propReceiverDescriptor) && CodegenUtil.isInterface(receiverType.getConstructor().getDeclarationDescriptor())) { - // I hope it happens only in case of required super class for traits - assert propReceiverDescriptor != null; v.checkcast(asmType(propReceiverDescriptor.getDefaultType())); } } @@ -1161,7 +1158,9 @@ public class ExpressionCodegen extends JetVisitor { if (descriptor instanceof TypeParameterDescriptor) { TypeParameterDescriptor typeParameterDescriptor = (TypeParameterDescriptor) descriptor; v.invokevirtual("jet/TypeInfo", "getClassObject", "()Ljava/lang/Object;"); - v.checkcast(asmType(typeParameterDescriptor.getClassObjectType())); + JetType type = typeParameterDescriptor.getClassObjectType(); + assert type != null; + v.checkcast(asmType(type)); return StackValue.onStack(TYPE_OBJECT); } @@ -1188,6 +1187,7 @@ public class ExpressionCodegen extends JetVisitor { if (descriptor instanceof ValueParameterDescriptor && descriptor.getContainingDeclaration() instanceof ScriptDescriptor) { ScriptDescriptor scriptDescriptor = (ScriptDescriptor) descriptor.getContainingDeclaration(); final ClosureAnnotator closureAnnotator = state.getInjector().getClosureAnnotator(); + assert scriptDescriptor != null; JvmClassName scriptClassName = closureAnnotator.classNameForScriptDescriptor(scriptDescriptor); ValueParameterDescriptor valueParameterDescriptor = (ValueParameterDescriptor) descriptor; final ClassDescriptor scriptClass = closureAnnotator.classDescriptorForScriptDescriptor(scriptDescriptor); @@ -1246,7 +1246,9 @@ public class ExpressionCodegen extends JetVisitor { int opcode = isStatic ? Opcodes.INVOKESTATIC : isInterface ? Opcodes.INVOKEINTERFACE : Opcodes.INVOKEVIRTUAL; v.visitMethodInsn(opcode, owner.getInternalName(), functionDescriptor.getName().getName(), typeMapper.mapSignature(functionDescriptor.getName(), functionDescriptor).getAsmMethod().getDescriptor()); - StackValue.onStack(asmType(functionDescriptor.getReturnType())).coerce(type, v); + JetType returnType = functionDescriptor.getReturnType(); + assert returnType != null; + StackValue.onStack(asmType(returnType)).coerce(type, v); } public StackValue.Property intermediateValueForProperty( @@ -1359,8 +1361,9 @@ public class ExpressionCodegen extends JetVisitor { } private PropertyDescriptor accessablePropertyDescriptor(PropertyDescriptor propertyDescriptor) { + PropertySetterDescriptor setter = propertyDescriptor.getSetter(); if ((propertyDescriptor.getVisibility() == Visibilities.PRIVATE || - (propertyDescriptor.getSetter() != null && propertyDescriptor.getSetter().getVisibility() == Visibilities.PRIVATE)) + (setter != null && setter.getVisibility() == Visibilities.PRIVATE)) && !DescriptorUtils.isClassObject(propertyDescriptor.getContainingDeclaration()) && propertyDescriptor.getContainingDeclaration() instanceof ClassDescriptor) { if (context.getClassOrNamespaceDescriptor() != propertyDescriptor.getContainingDeclaration()) { @@ -1447,6 +1450,7 @@ public class ExpressionCodegen extends JetVisitor { while (!(c instanceof CodegenContexts.ClassContext) || !DescriptorUtils.isSubclass(c.getThisDescriptor(), enclosed)) { c = c.getParentContext(); + assert c != null; } fd = (FunctionDescriptor) c.getAccessor(fd); superCall = false; @@ -1465,6 +1469,7 @@ public class ExpressionCodegen extends JetVisitor { CodegenContext c = context; while (c.getContextDescriptor() != enclosed) { c = c.getParentContext(); + assert c != null; } fd = (FunctionDescriptor) c.getAccessor(fd); } @@ -1487,7 +1492,9 @@ public class ExpressionCodegen extends JetVisitor { for (ValueArgument argument : expression.getValueArguments()) { args.add(argument.getArgumentExpression()); } - Type callType = typeMapper.mapType(resolvedCall.getCandidateDescriptor().getReturnType(), MapTypeMode.VALUE); + JetType type = resolvedCall.getCandidateDescriptor().getReturnType(); + assert type != null; + Type callType = typeMapper.mapType(type, MapTypeMode.VALUE); Type exprType = expressionType(expression); StackValue stackValue = intrinsic.generate(this, v, callType, expression, args, receiver, state); stackValue.put(exprType, v); @@ -1497,7 +1504,9 @@ public class ExpressionCodegen extends JetVisitor { private StackValue returnValueAsStackValue(FunctionDescriptor fd, Type callReturnType) { if (callReturnType != Type.VOID_TYPE) { - final Type retType = typeMapper.mapReturnType(fd.getReturnType()); + JetType type = fd.getReturnType(); + assert type != null; + final Type retType = typeMapper.mapReturnType(type); StackValue.onStack(callReturnType).upcast(retType, v); return StackValue.onStack(retType); } @@ -1528,6 +1537,7 @@ public class ExpressionCodegen extends JetVisitor { private boolean isCallAsFunctionObject(FunctionDescriptor fd) { if (fd.getContainingDeclaration() instanceof ScriptDescriptor) { JetNamedFunction psi = (JetNamedFunction) BindingContextUtils.descriptorToDeclaration(bindingContext, fd); + assert psi != null; return !psi.isScriptDeclaration(); } else if (fd instanceof ExpressionAsFunctionDescriptor) { @@ -1651,11 +1661,6 @@ public class ExpressionCodegen extends JetVisitor { private void generateScript(@NotNull ScriptReceiver receiver) { CodegenContext cur = context; - - //PsiElement psiElement = BindingContextUtils.classDescriptorToDeclaration(bindingContext, calleeContainingClass); - //boolean isObject = psiElement instanceof JetClassOrObject && CodegenUtil.isNonLiteralObject((JetClassOrObject) psiElement); - - cur = context; StackValue result = StackValue.local(0, TYPE_OBJECT); while (cur != null) { if (cur instanceof CodegenContexts.MethodContext && !(cur instanceof CodegenContexts.ConstructorContext)) { @@ -1680,11 +1685,13 @@ public class ExpressionCodegen extends JetVisitor { return; } + assert cur != null; result = cur.getOuterExpression(result); if (cur instanceof CodegenContexts.ConstructorContext) { cur = cur.getParentContext(); } + assert cur != null; cur = cur.getParentContext(); } @@ -1703,6 +1710,8 @@ public class ExpressionCodegen extends JetVisitor { cur = cur.getParentContext(); } + + assert cur != null; if (DescriptorUtils.isSubclass(cur.getThisDescriptor(), calleeContainingClass)) { if (!isObject || (cur.getThisDescriptor() == calleeContainingClass)) { return castToRequiredTypeOfInterfaceIfNeeded(result, cur.getThisDescriptor(), calleeContainingClass); @@ -1717,6 +1726,7 @@ public class ExpressionCodegen extends JetVisitor { if (cur instanceof CodegenContexts.ConstructorContext) { cur = cur.getParentContext(); } + assert cur != null; cur = cur.getParentContext(); } @@ -1748,6 +1758,7 @@ public class ExpressionCodegen extends JetVisitor { ResolvedValueArgument resolvedValueArgument = valueArguments.get(valueParameterDescriptor.getIndex()); if (resolvedValueArgument instanceof ExpressionValueArgument) { ExpressionValueArgument valueArgument = (ExpressionValueArgument) resolvedValueArgument; + //noinspection ConstantConditions gen(valueArgument.getValueArgument().getArgumentExpression(), valueParameterTypes.get(index)); } else if (resolvedValueArgument instanceof DefaultValueArgument) { @@ -1877,9 +1888,9 @@ public class ExpressionCodegen extends JetVisitor { public StackValue visitSafeQualifiedExpression(JetSafeQualifiedExpression expression, StackValue receiver) { JetExpression expr = expression.getReceiverExpression(); JetType receiverJetType = bindingContext.get(BindingContext.EXPRESSION_TYPE, expression.getReceiverExpression()); + assert receiverJetType != null; Type receiverType = asmType(receiverJetType); gen(expr, receiverType); - assert receiverJetType != null; if (!receiverJetType.isNullable()) { StackValue propValue = genQualified(StackValue.onStack(receiverType), expression.getSelectorExpression()); Type type = propValue.type; @@ -2059,8 +2070,10 @@ public class ExpressionCodegen extends JetVisitor { private StackValue generateEquals(JetExpression left, JetExpression right, IElementType opToken) { JetType leftJetType = bindingContext.get(BindingContext.EXPRESSION_TYPE, left); + assert leftJetType != null; Type leftType = asmType(leftJetType); JetType rightJetType = bindingContext.get(BindingContext.EXPRESSION_TYPE, right); + assert rightJetType != null; Type rightType = asmType(rightJetType); if (leftType == TYPE_NOTHING) { return genCmpWithNull(right, rightType, opToken); @@ -2088,8 +2101,6 @@ public class ExpressionCodegen extends JetVisitor { return generateEqualsForExpressionsOnStack(opToken, leftType, rightType, false, false); } - assert leftJetType != null; - assert rightJetType != null; return generateEqualsForExpressionsOnStack(opToken, leftType, rightType, leftJetType.isNullable(), rightJetType.isNullable()); } @@ -2274,8 +2285,10 @@ public class ExpressionCodegen extends JetVisitor { value.put(lhsType, v); // receiver lhs final IntrinsicMethod intrinsic = (IntrinsicMethod) callable; //noinspection NullableProblems + JetExpression right = expression.getRight(); + assert right != null; StackValue stackValue = intrinsic.generate(this, v, lhsType, expression, - Arrays.asList(expression.getRight()), + Arrays.asList(right), StackValue.onStack(lhsType), state); value.store(stackValue.type, v); } @@ -2284,8 +2297,9 @@ public class ExpressionCodegen extends JetVisitor { } } else { - assert op != null; - final boolean keepReturnValue = !((FunctionDescriptor) op).getReturnType().equals(JetStandardClasses.getUnitType()); + JetType type = ((FunctionDescriptor) op).getReturnType(); + assert type != null; + final boolean keepReturnValue = !type.equals(JetStandardClasses.getUnitType()); callAugAssignMethod(expression, (CallableMethod) callable, lhsType, keepReturnValue); } @@ -2351,7 +2365,7 @@ public class ExpressionCodegen extends JetVisitor { v.invokevirtual("java/lang/StringBuilder", "append", appendDescriptor.getDescriptor()); } - private JetSimpleNameExpression targetLabel(JetExpression expression) { + private static JetSimpleNameExpression targetLabel(JetExpression expression) { if (expression.getParent() instanceof JetPrefixExpression) { JetPrefixExpression parent = (JetPrefixExpression) expression.getParent(); JetSimpleNameExpression operationSign = parent.getOperationReference(); @@ -2373,6 +2387,7 @@ public class ExpressionCodegen extends JetVisitor { final Callable callable = resolveToCallable((FunctionDescriptor) op, false); if (callable instanceof IntrinsicMethod) { IntrinsicMethod intrinsic = (IntrinsicMethod) callable; + //noinspection ConstantConditions return intrinsic.generate(this, v, expressionType(expression), expression, Arrays.asList(expression.getBaseExpression()), receiver, state); } @@ -2544,14 +2559,10 @@ public class ExpressionCodegen extends JetVisitor { VariableDescriptor variableDescriptor = bindingContext.get(BindingContext.VARIABLE, property); - Type sharedVarType = null; - int index = -1; + Type sharedVarType; + int index; if (property.isScriptDeclaration()) { - JetScript scriptPsi = property.getScript(); - JvmClassName scriptClassName = state.getInjector().getClosureAnnotator().classNameForScriptPsi(scriptPsi); - StackValue field = StackValue - .field(typeMapper.mapType(variableDescriptor.getType(), MapTypeMode.VALUE), scriptClassName, property.getName(), false); return StackValue.none(); } else { @@ -2578,6 +2589,7 @@ public class ExpressionCodegen extends JetVisitor { if (property.isScriptDeclaration()) { gen(initializer, varType); JetScript scriptPsi = property.getScript(); + assert scriptPsi != null; JvmClassName scriptClassName = state.getInjector().getClosureAnnotator().classNameForScriptPsi(scriptPsi); v.putfield(scriptClassName.getInternalName(), property.getName(), varType.getDescriptor()); } @@ -2601,6 +2613,7 @@ public class ExpressionCodegen extends JetVisitor { StackValue receiver ) { DeclarationDescriptor constructorDescriptor = bindingContext.get(BindingContext.REFERENCE_TARGET, constructorReference); + assert constructorDescriptor != null; final PsiElement declaration = BindingContextUtils.descriptorToDeclaration(bindingContext, constructorDescriptor); Type type; if (declaration instanceof PsiMethod) { @@ -2615,8 +2628,6 @@ public class ExpressionCodegen extends JetVisitor { generateNewArray(expression, expressionType); } else { - ClassDescriptor classDecl = (ClassDescriptor) constructorDescriptor.getContainingDeclaration(); - v.anew(type); v.dup(); @@ -2762,16 +2773,15 @@ public class ExpressionCodegen extends JetVisitor { Type[] argumentTypes = accessor.getSignature().getAsmMethod().getArgumentTypes(); int index = 0; if (isGetter) { + assert getterDescriptor != null; Callable callable = resolveToCallable(getterDescriptor, false); if (callable instanceof CallableMethod) { genThisAndReceiverFromResolvedCall(receiver, resolvedGetCall, (CallableMethod) callable); } else { - assert getterDescriptor != null; gen(array, asmType(((ClassDescriptor) getterDescriptor.getContainingDeclaration()).getDefaultType())); } - assert getterDescriptor != null; if (getterDescriptor.getReceiverParameter().exists()) { index++; } @@ -2836,6 +2846,7 @@ The "returned" value of try expression with no finally is either the last expres } JetType jetType = bindingContext.get(BindingContext.EXPRESSION_TYPE, expression); + assert jetType != null; Type expectedAsmType = asmType(jetType); Label tryStart = new Label(); @@ -2930,8 +2941,8 @@ The "returned" value of try expression with no finally is either the last expres else { JetTypeReference typeReference = expression.getRight(); JetType rightType = bindingContext.get(BindingContext.TYPE, typeReference); - Type rightTypeAsm = boxType(asmType(rightType)); assert rightType != null; + Type rightTypeAsm = boxType(asmType(rightType)); JetExpression left = expression.getLeft(); JetType leftType = bindingContext.get(BindingContext.EXPRESSION_TYPE, left); DeclarationDescriptor descriptor = rightType.getConstructor().getDeclarationDescriptor(); @@ -3002,6 +3013,7 @@ The "returned" value of try expression with no finally is either the last expres JetType condJetType = bindingContext.get(BindingContext.EXPRESSION_TYPE, condExpression); Type condType; if (isNumberPrimitive(subjectType) || subjectType.getSort() == Type.BOOLEAN) { + assert condJetType != null; condType = asmType(condJetType); if (!(isNumberPrimitive(condType) || condType.getSort() == Type.BOOLEAN)) { subjectType = JetTypeMapper.boxType(subjectType);