From 8a1b9933e46e60d11ebeae77094f05eea8dc4e73 Mon Sep 17 00:00:00 2001 From: Dmitry Jemerov Date: Thu, 30 Jun 2011 16:48:13 +0200 Subject: [PATCH] assorted fixes to handle boxing correctly when calling generic methods/properties; rename getUnsubstitutedValueParameters/ReturnType to getValueParameters/ReturnType --- .../jetbrains/jet/codegen/ClosureCodegen.java | 12 +++++----- .../jet/codegen/ConstructorFrameMap.java | 2 +- .../jet/codegen/ExpressionCodegen.java | 11 +++++----- .../jet/codegen/FunctionCodegen.java | 2 +- .../codegen/ImplementationBodyCodegen.java | 4 ++-- .../jetbrains/jet/codegen/JetTypeMapper.java | 12 +++++----- .../jet/codegen/PropertyCodegen.java | 2 +- .../org/jetbrains/jet/codegen/StackValue.java | 1 + .../descriptors/ConstructorDescriptor.java | 2 +- .../lang/descriptors/FunctionDescriptor.java | 4 ++-- .../descriptors/FunctionDescriptorImpl.java | 4 ++-- .../descriptors/FunctionDescriptorUtil.java | 22 +++++++++---------- .../descriptors/PropertyGetterDescriptor.java | 4 ++-- .../descriptors/PropertySetterDescriptor.java | 4 ++-- .../jet/lang/psi/JetSimpleNameExpression.java | 4 ++-- .../jet/lang/resolve/OverloadResolver.java | 6 ++--- .../jet/lang/resolve/TopDownAnalyzer.java | 10 ++++----- .../jet/lang/types/JetTypeInferrer.java | 20 ++++++++--------- .../jet/resolve/DescriptorRenderer.java | 4 ++-- idea/testData/codegen/classes/simpleBox.jet | 8 +++++++ .../jetbrains/jet/codegen/ClassGenTest.java | 4 ++++ .../jetbrains/jet/resolve/JetResolveTest.java | 2 +- 22 files changed, 79 insertions(+), 65 deletions(-) create mode 100644 idea/testData/codegen/classes/simpleBox.jet diff --git a/idea/src/org/jetbrains/jet/codegen/ClosureCodegen.java b/idea/src/org/jetbrains/jet/codegen/ClosureCodegen.java index de3765bdcf5..e5eac77e99d 100644 --- a/idea/src/org/jetbrains/jet/codegen/ClosureCodegen.java +++ b/idea/src/org/jetbrains/jet/codegen/ClosureCodegen.java @@ -38,7 +38,7 @@ public class ClosureCodegen { public static Method erasedInvokeSignature(FunctionDescriptor fd) { boolean isExtensionFunction = fd.getReceiverType() != null; - int paramCount = fd.getUnsubstitutedValueParameters().size(); + int paramCount = fd.getValueParameters().size(); if (isExtensionFunction) { paramCount++; } @@ -87,14 +87,14 @@ public class ClosureCodegen { SignatureWriter signatureWriter = new SignatureWriter(); - final List parameters = funDescriptor.getUnsubstitutedValueParameters(); + final List parameters = funDescriptor.getValueParameters(); final String funClass = getInternalClassName(funDescriptor); signatureWriter.visitClassType(funClass); for (ValueParameterDescriptor parameter : parameters) { appendType(signatureWriter, parameter.getOutType(), '='); } - appendType(signatureWriter, funDescriptor.getUnsubstitutedReturnType(), '='); + appendType(signatureWriter, funDescriptor.getReturnType(), '='); signatureWriter.visitEnd(); cv.visit(Opcodes.V1_6, @@ -123,7 +123,7 @@ public class ClosureCodegen { private void generateBody(FunctionDescriptor funDescriptor, ClassVisitor cv, List body) { FunctionCodegen fc = new FunctionCodegen(null, cv, state); - fc.generatedMethod(body, OwnerKind.IMPLEMENTATION, invokeSignature(funDescriptor), funDescriptor.getReceiverType(), funDescriptor.getUnsubstitutedValueParameters(), null); + fc.generatedMethod(body, OwnerKind.IMPLEMENTATION, invokeSignature(funDescriptor), funDescriptor.getReceiverType(), funDescriptor.getValueParameters(), null); } private void generateBridge(String className, FunctionDescriptor funDescriptor, ClassVisitor cv) { @@ -145,7 +145,7 @@ public class ClosureCodegen { count++; } - final List params = funDescriptor.getUnsubstitutedValueParameters(); + final List params = funDescriptor.getValueParameters(); for (ValueParameterDescriptor param : params) { StackValue.local(count, JetTypeMapper.TYPE_OBJECT).put(JetTypeMapper.TYPE_OBJECT, iv); StackValue.onStack(JetTypeMapper.TYPE_OBJECT).upcast(state.getTypeMapper().mapType(param.getOutType()), iv); @@ -191,7 +191,7 @@ public class ClosureCodegen { } public static String getInternalClassName(FunctionDescriptor descriptor) { - final int paramCount = descriptor.getUnsubstitutedValueParameters().size(); + final int paramCount = descriptor.getValueParameters().size(); if (descriptor.getReceiverType() != null) { return "jet/ExtensionFunction" + paramCount; } diff --git a/idea/src/org/jetbrains/jet/codegen/ConstructorFrameMap.java b/idea/src/org/jetbrains/jet/codegen/ConstructorFrameMap.java index 656b8b0cb4d..f0b94c6270b 100644 --- a/idea/src/org/jetbrains/jet/codegen/ConstructorFrameMap.java +++ b/idea/src/org/jetbrains/jet/codegen/ConstructorFrameMap.java @@ -52,7 +52,7 @@ public class ConstructorFrameMap extends FrameMap { } List paramDescrs = descriptor != null - ? descriptor.getUnsubstitutedValueParameters() + ? descriptor.getValueParameters() : Collections.emptyList(); for (int i = 0; i < paramDescrs.size(); i++) { ValueParameterDescriptor parameter = paramDescrs.get(i); diff --git a/idea/src/org/jetbrains/jet/codegen/ExpressionCodegen.java b/idea/src/org/jetbrains/jet/codegen/ExpressionCodegen.java index 4edbf4b725a..6606dc7bcbf 100644 --- a/idea/src/org/jetbrains/jet/codegen/ExpressionCodegen.java +++ b/idea/src/org/jetbrains/jet/codegen/ExpressionCodegen.java @@ -608,7 +608,7 @@ public class ExpressionCodegen extends JetVisitor { if (PsiTreeUtil.getParentOfType(expression, JetDelegationSpecifier.class) != null) { JetClass aClass = PsiTreeUtil.getParentOfType(expression, JetClass.class); ConstructorDescriptor constructorDescriptor = bindingContext.getConstructorDescriptor(aClass); - List parameters = constructorDescriptor.getUnsubstitutedValueParameters(); + List parameters = constructorDescriptor.getValueParameters(); for (ValueParameterDescriptor parameter : parameters) { if (parameter.getName().equals(descriptor.getName())) { final JetType outType = ((VariableDescriptor) descriptor).getOutType(); @@ -663,6 +663,7 @@ public class ExpressionCodegen extends JetVisitor { public StackValue intermediateValueForProperty(PropertyDescriptor propertyDescriptor, final boolean forceField, boolean forceInterface) { DeclarationDescriptor containingDeclaration = propertyDescriptor.getContainingDeclaration(); boolean isStatic = containingDeclaration instanceof NamespaceDescriptorImpl; + propertyDescriptor = propertyDescriptor.getOriginal(); final JetType outType = propertyDescriptor.getOutType(); boolean isInsideClass = !forceInterface && containingDeclaration == contextType; Method getter; @@ -750,7 +751,7 @@ public class ExpressionCodegen extends JetVisitor { ProjectScope.getAllScope(project)); // TODO better overload mapping final PsiMethod[] methods = jlString.findMethodsByName(funDescriptor.getName(), false); - final int arity = fd.getUnsubstitutedValueParameters().size(); + final int arity = fd.getValueParameters().size(); for (PsiMethod method : methods) { if (method.getParameterList().getParametersCount() == arity) { declarationPsiElement = method; @@ -815,7 +816,7 @@ public class ExpressionCodegen extends JetVisitor { gen(callee, Type.getObjectType(ClosureCodegen.getInternalClassName(fd))); boolean isExtensionFunction = fd.getReceiverType() != null; - int paramCount = fd.getUnsubstitutedValueParameters().size(); + int paramCount = fd.getValueParameters().size(); if (isExtensionFunction) { ensureReceiverOnStack(expression, null); paramCount++; @@ -827,7 +828,7 @@ public class ExpressionCodegen extends JetVisitor { } if (methodDescriptor.getReturnType() != Type.VOID_TYPE) { - final Type retType = typeMapper.mapType(fd.getUnsubstitutedReturnType()); + final Type retType = typeMapper.mapType(fd.getReturnType()); StackValue.onStack(methodDescriptor.getReturnType()).upcast(retType, v); myStack.push(StackValue.onStack(retType)); } @@ -1206,7 +1207,7 @@ public class ExpressionCodegen extends JetVisitor { } private void generateBinaryOp(JetBinaryExpression expression, FunctionDescriptor op, int opcode) { - JetType returnType = op.getUnsubstitutedReturnType(); + JetType returnType = op.getReturnType(); final Type asmType = typeMapper.mapType(returnType); if (asmType == Type.INT_TYPE || asmType == Type.LONG_TYPE || asmType == Type.FLOAT_TYPE || asmType == Type.DOUBLE_TYPE) { diff --git a/idea/src/org/jetbrains/jet/codegen/FunctionCodegen.java b/idea/src/org/jetbrains/jet/codegen/FunctionCodegen.java index 98517b007b2..787fab71c3b 100644 --- a/idea/src/org/jetbrains/jet/codegen/FunctionCodegen.java +++ b/idea/src/org/jetbrains/jet/codegen/FunctionCodegen.java @@ -33,7 +33,7 @@ public class FunctionCodegen { final JetTypeReference receiverTypeRef = f.getReceiverTypeRef(); final JetType receiverType = receiverTypeRef == null ? null : state.getBindingContext().resolveTypeReference(receiverTypeRef); Method method = state.getTypeMapper().mapSignature(f); - List paramDescrs = state.getBindingContext().getFunctionDescriptor(f).getUnsubstitutedValueParameters(); + List paramDescrs = state.getBindingContext().getFunctionDescriptor(f).getValueParameters(); generateMethod(f, kind, method, receiverType, paramDescrs); } diff --git a/idea/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java b/idea/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java index aebceb809e1..51106f271f0 100644 --- a/idea/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java +++ b/idea/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java @@ -99,7 +99,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { Type[] argTypes = method.getArgumentTypes(); List paramDescrs = constructorDescriptor != null - ? constructorDescriptor.getUnsubstitutedValueParameters() + ? constructorDescriptor.getValueParameters() : Collections.emptyList(); ConstructorFrameMap frameMap = new ConstructorFrameMap(state.getTypeMapper(), constructorDescriptor, kind); @@ -252,7 +252,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { } Method method = state.getTypeMapper().mapConstructorSignature(constructorDescriptor, kind); - List valueParameters = constructorDescriptor.getUnsubstitutedValueParameters(); + List valueParameters = constructorDescriptor.getValueParameters(); List args = constructorCall.getValueArguments(); for (int i = 0, argsSize = args.size(); i < argsSize; i++) { JetArgument arg = args.get(i); diff --git a/idea/src/org/jetbrains/jet/codegen/JetTypeMapper.java b/idea/src/org/jetbrains/jet/codegen/JetTypeMapper.java index 5d27e583be9..899e4f41097 100644 --- a/idea/src/org/jetbrains/jet/codegen/JetTypeMapper.java +++ b/idea/src/org/jetbrains/jet/codegen/JetTypeMapper.java @@ -286,7 +286,7 @@ public class JetTypeMapper { Type returnType; if (returnTypeRef == null) { final FunctionDescriptor functionDescriptor = bindingContext.getFunctionDescriptor(f); - final JetType type = functionDescriptor.getUnsubstitutedReturnType(); + final JetType type = functionDescriptor.getReturnType(); returnType = mapType(type); } else { @@ -297,7 +297,7 @@ public class JetTypeMapper { public Method mapSignature(String name, FunctionDescriptor f) { final JetType receiverType = f.getReceiverType(); - final List parameters = f.getUnsubstitutedValueParameters(); + final List parameters = f.getValueParameters(); List parameterTypes = new ArrayList(); if (receiverType != null) { parameterTypes.add(mapType(receiverType)); @@ -305,7 +305,7 @@ public class JetTypeMapper { for (ValueParameterDescriptor parameter : parameters) { parameterTypes.add(mapType(parameter.getOutType())); } - Type returnType = mapType(f.getUnsubstitutedReturnType()); + Type returnType = mapType(f.getReturnType()); return new Method(name, returnType, parameterTypes.toArray(new Type[parameterTypes.size()])); } @@ -321,12 +321,12 @@ public class JetTypeMapper { } answer.append('('); - for (ValueParameterDescriptor p : f.getUnsubstitutedValueParameters()) { + for (ValueParameterDescriptor p : f.getValueParameters()) { appendType(answer, p.getOutType()); } answer.append(')'); - appendType(answer, f.getUnsubstitutedReturnType()); + appendType(answer, f.getReturnType()); return answer.toString(); } @@ -355,7 +355,7 @@ public class JetTypeMapper { public Method mapConstructorSignature(ConstructorDescriptor descriptor, OwnerKind kind) { boolean delegate = kind == OwnerKind.DELEGATING_IMPLEMENTATION; - List parameters = descriptor.getUnsubstitutedValueParameters(); + List parameters = descriptor.getOriginal().getValueParameters(); List parameterTypes = new ArrayList(); ClassDescriptor classDescriptor = descriptor.getContainingDeclaration(); final DeclarationDescriptor outerDescriptor = classDescriptor.getContainingDeclaration(); diff --git a/idea/src/org/jetbrains/jet/codegen/PropertyCodegen.java b/idea/src/org/jetbrains/jet/codegen/PropertyCodegen.java index 0d224317dc9..6ad1bda0992 100644 --- a/idea/src/org/jetbrains/jet/codegen/PropertyCodegen.java +++ b/idea/src/org/jetbrains/jet/codegen/PropertyCodegen.java @@ -119,7 +119,7 @@ public class PropertyCodegen { final PropertySetterDescriptor setterDescriptor = propertyDescriptor.getSetter(); assert setterDescriptor != null; functionCodegen.generateMethod(setter, kind, mapper.mapSetterSignature(propertyDescriptor), - null, setterDescriptor.getUnsubstitutedValueParameters()); + null, setterDescriptor.getValueParameters()); } else if (!p.hasModifier(JetTokens.PRIVATE_KEYWORD)) { generateDefaultSetter(p, setter, kind); diff --git a/idea/src/org/jetbrains/jet/codegen/StackValue.java b/idea/src/org/jetbrains/jet/codegen/StackValue.java index 36098d1c3a6..1cab78d0637 100644 --- a/idea/src/org/jetbrains/jet/codegen/StackValue.java +++ b/idea/src/org/jetbrains/jet/codegen/StackValue.java @@ -440,6 +440,7 @@ public abstract class StackValue { else { v.visitMethodInsn(isStatic ? Opcodes.INVOKESTATIC : isInterface ? Opcodes.INVOKEINTERFACE : Opcodes.INVOKEVIRTUAL, owner, getter.getName(), getter.getDescriptor()); } + coerce(type, v); } @Override diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/ConstructorDescriptor.java b/idea/src/org/jetbrains/jet/lang/descriptors/ConstructorDescriptor.java index e3b4262fbd8..a7cc556ea05 100644 --- a/idea/src/org/jetbrains/jet/lang/descriptors/ConstructorDescriptor.java +++ b/idea/src/org/jetbrains/jet/lang/descriptors/ConstructorDescriptor.java @@ -21,7 +21,7 @@ public interface ConstructorDescriptor extends FunctionDescriptor { */ @NotNull @Override - JetType getUnsubstitutedReturnType(); + JetType getReturnType(); @NotNull @Override diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptor.java b/idea/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptor.java index 60848f035e6..48c2622d412 100644 --- a/idea/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptor.java +++ b/idea/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptor.java @@ -23,10 +23,10 @@ public interface FunctionDescriptor extends DeclarationDescriptor { List getTypeParameters(); @NotNull - List getUnsubstitutedValueParameters(); + List getValueParameters(); @NotNull - JetType getUnsubstitutedReturnType(); + JetType getReturnType(); @NotNull FunctionDescriptor getOriginal(); diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorImpl.java b/idea/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorImpl.java index a8cfa9e5ce2..f3312c917a4 100644 --- a/idea/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorImpl.java +++ b/idea/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorImpl.java @@ -79,13 +79,13 @@ public class FunctionDescriptorImpl extends DeclarationDescriptorImpl implements @Override @NotNull - public List getUnsubstitutedValueParameters() { + public List getValueParameters() { return unsubstitutedValueParameters; } @Override @NotNull - public JetType getUnsubstitutedReturnType() { + public JetType getReturnType() { return unsubstitutedReturnType; } diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorUtil.java b/idea/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorUtil.java index bac10421d8f..bb623b32761 100644 --- a/idea/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorUtil.java +++ b/idea/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorUtil.java @@ -20,7 +20,7 @@ public class FunctionDescriptorUtil { /** @return Minimal number of arguments to be passed */ public static int getMinimumArity(@NotNull FunctionDescriptor functionDescriptor) { int result = 0; - for (ValueParameterDescriptor valueParameter : functionDescriptor.getUnsubstitutedValueParameters()) { + for (ValueParameterDescriptor valueParameter : functionDescriptor.getValueParameters()) { if (valueParameter.hasDefaultValue()) { break; } @@ -33,7 +33,7 @@ public class FunctionDescriptorUtil { * @return Maximum number of arguments that can be passed. -1 if unbound (vararg) */ public static int getMaximumArity(@NotNull FunctionDescriptor functionDescriptor) { - List unsubstitutedValueParameters = functionDescriptor.getUnsubstitutedValueParameters(); + List unsubstitutedValueParameters = functionDescriptor.getValueParameters(); if (unsubstitutedValueParameters.isEmpty()) { return 0; } @@ -65,7 +65,7 @@ public class FunctionDescriptorUtil { @Nullable public static List getSubstitutedValueParameters(FunctionDescriptor substitutedDescriptor, @NotNull FunctionDescriptor functionDescriptor, TypeSubstitutor substitutor) { List result = new ArrayList(); - List unsubstitutedValueParameters = functionDescriptor.getUnsubstitutedValueParameters(); + List unsubstitutedValueParameters = functionDescriptor.getValueParameters(); for (int i = 0, unsubstitutedValueParametersSize = unsubstitutedValueParameters.size(); i < unsubstitutedValueParametersSize; i++) { ValueParameterDescriptor unsubstitutedValueParameter = unsubstitutedValueParameters.get(i); // TODO : Lazy? @@ -87,7 +87,7 @@ public class FunctionDescriptorUtil { @Nullable public static JetType getSubstitutedReturnType(@NotNull FunctionDescriptor functionDescriptor, TypeSubstitutor substitutor) { - return substitutor.substitute(functionDescriptor.getUnsubstitutedReturnType(), Variance.OUT_VARIANCE); + return substitutor.substitute(functionDescriptor.getReturnType(), Variance.OUT_VARIANCE); } @Nullable @@ -106,7 +106,7 @@ public class FunctionDescriptorUtil { for (TypeParameterDescriptor typeParameter : descriptor.getTypeParameters()) { parameterScope.addTypeParameterDescriptor(typeParameter); } - for (ValueParameterDescriptor valueParameterDescriptor : descriptor.getUnsubstitutedValueParameters()) { + for (ValueParameterDescriptor valueParameterDescriptor : descriptor.getValueParameters()) { parameterScope.addVariableDescriptor(valueParameterDescriptor); } parameterScope.addLabeledDeclaration(descriptor); @@ -183,7 +183,7 @@ public class FunctionDescriptorUtil { return OverrideCompatibilityInfo.typeParameterNumberMismatch(); } - if (superFunction.getUnsubstitutedValueParameters().size() != subFunction.getUnsubstitutedValueParameters().size()) { + if (superFunction.getValueParameters().size() != subFunction.getValueParameters().size()) { return OverrideCompatibilityInfo.valueParameterNumberMismatch(); } @@ -211,8 +211,8 @@ public class FunctionDescriptorUtil { } } - List superValueParameters = superFunction.getUnsubstitutedValueParameters(); - List subValueParameters = subFunction.getUnsubstitutedValueParameters(); + List superValueParameters = superFunction.getValueParameters(); + List subValueParameters = subFunction.getValueParameters(); for (int i = 0, unsubstitutedValueParametersSize = superValueParameters.size(); i < unsubstitutedValueParametersSize; i++) { ValueParameterDescriptor superValueParameter = superValueParameters.get(i); ValueParameterDescriptor subValueParameter = subValueParameters.get(i); @@ -225,10 +225,10 @@ public class FunctionDescriptorUtil { // TODO : Default values, varargs etc TypeSubstitutor typeSubstitutor = TypeSubstitutor.create(substitutionContext); - JetType substitutedSuperReturnType = typeSubstitutor.substitute(superFunction.getUnsubstitutedReturnType(), Variance.OUT_VARIANCE); + JetType substitutedSuperReturnType = typeSubstitutor.substitute(superFunction.getReturnType(), Variance.OUT_VARIANCE); assert substitutedSuperReturnType != null; - if (!typeChecker.isSubtypeOf(subFunction.getUnsubstitutedReturnType(), substitutedSuperReturnType)) { - return OverrideCompatibilityInfo.returnTypeMismatch(substitutedSuperReturnType, subFunction.getUnsubstitutedReturnType()); + if (!typeChecker.isSubtypeOf(subFunction.getReturnType(), substitutedSuperReturnType)) { + return OverrideCompatibilityInfo.returnTypeMismatch(substitutedSuperReturnType, subFunction.getReturnType()); } return OverrideCompatibilityInfo.success(); diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/PropertyGetterDescriptor.java b/idea/src/org/jetbrains/jet/lang/descriptors/PropertyGetterDescriptor.java index 4adcb040da5..5ee0308a885 100644 --- a/idea/src/org/jetbrains/jet/lang/descriptors/PropertyGetterDescriptor.java +++ b/idea/src/org/jetbrains/jet/lang/descriptors/PropertyGetterDescriptor.java @@ -38,13 +38,13 @@ public class PropertyGetterDescriptor extends PropertyAccessorDescriptor { @NotNull @Override - public List getUnsubstitutedValueParameters() { + public List getValueParameters() { return Collections.emptyList(); } @NotNull @Override - public JetType getUnsubstitutedReturnType() { + public JetType getReturnType() { return returnType; } diff --git a/idea/src/org/jetbrains/jet/lang/descriptors/PropertySetterDescriptor.java b/idea/src/org/jetbrains/jet/lang/descriptors/PropertySetterDescriptor.java index b9307102889..2ba62bdfbe1 100644 --- a/idea/src/org/jetbrains/jet/lang/descriptors/PropertySetterDescriptor.java +++ b/idea/src/org/jetbrains/jet/lang/descriptors/PropertySetterDescriptor.java @@ -47,13 +47,13 @@ public class PropertySetterDescriptor extends PropertyAccessorDescriptor { @NotNull @Override - public List getUnsubstitutedValueParameters() { + public List getValueParameters() { return Collections.singletonList(parameter); } @NotNull @Override - public JetType getUnsubstitutedReturnType() { + public JetType getReturnType() { return JetStandardClasses.getUnitType(); } diff --git a/idea/src/org/jetbrains/jet/lang/psi/JetSimpleNameExpression.java b/idea/src/org/jetbrains/jet/lang/psi/JetSimpleNameExpression.java index f1c78d59f5d..98b6e166ba0 100644 --- a/idea/src/org/jetbrains/jet/lang/psi/JetSimpleNameExpression.java +++ b/idea/src/org/jetbrains/jet/lang/psi/JetSimpleNameExpression.java @@ -126,9 +126,9 @@ public class JetSimpleNameExpression extends JetReferenceExpression { boolean tailTextGrayed = false; if (descriptor instanceof FunctionDescriptor) { FunctionDescriptor functionDescriptor = (FunctionDescriptor) descriptor; - JetType returnType = functionDescriptor.getUnsubstitutedReturnType(); + JetType returnType = functionDescriptor.getReturnType(); typeText = DescriptorRenderer.TEXT.renderType(returnType); - tailText = "(" + StringUtil.join(functionDescriptor.getUnsubstitutedValueParameters(), new Function() { + tailText = "(" + StringUtil.join(functionDescriptor.getValueParameters(), new Function() { @Override public String fun(ValueParameterDescriptor valueParameterDescriptor) { return valueParameterDescriptor.getName() + ":" + diff --git a/idea/src/org/jetbrains/jet/lang/resolve/OverloadResolver.java b/idea/src/org/jetbrains/jet/lang/resolve/OverloadResolver.java index d99a470190d..432ec2cc843 100644 --- a/idea/src/org/jetbrains/jet/lang/resolve/OverloadResolver.java +++ b/idea/src/org/jetbrains/jet/lang/resolve/OverloadResolver.java @@ -75,7 +75,7 @@ public class OverloadResolver { continue; } - List parameters = descriptor.getUnsubstitutedValueParameters(); + List parameters = descriptor.getValueParameters(); if (parameters.size() >= positionedValueArgumentTypes.size()) { // possibly, some default values // possibly, nothing passed to a vararg @@ -153,8 +153,8 @@ public class OverloadResolver { } private boolean moreSpecific(FunctionDescriptor f, FunctionDescriptor g) { - List fParams = f.getUnsubstitutedValueParameters(); - List gParams = g.getUnsubstitutedValueParameters(); + List fParams = f.getValueParameters(); + List gParams = g.getValueParameters(); int fSize = fParams.size(); if (fSize != gParams.size()) return false; diff --git a/idea/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java b/idea/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java index 7af668c94cf..e4761ac25b6 100644 --- a/idea/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java +++ b/idea/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java @@ -661,7 +661,7 @@ public class TopDownAnalyzer { resolveSecondaryConstructorBody((JetConstructor) declaration, descriptor, ((MutableClassDescriptor) descriptor.getContainingDeclaration()).getScopeForMemberResolution()); - assert descriptor.getUnsubstitutedReturnType() != null; + assert descriptor.getReturnType() != null; } } @@ -743,7 +743,7 @@ public class TopDownAnalyzer { constructorScope.setThisType(descriptor.getContainingDeclaration().getDefaultType()); - for (ValueParameterDescriptor valueParameterDescriptor : descriptor.getUnsubstitutedValueParameters()) { + for (ValueParameterDescriptor valueParameterDescriptor : descriptor.getValueParameters()) { JetParameter parameter = (JetParameter) trace.getBindingContext().getDeclarationPsiElement(valueParameterDescriptor); if (parameter.getValOrVarNode() == null || !primary) { constructorScope.addVariableDescriptor(valueParameterDescriptor); @@ -865,7 +865,7 @@ public class TopDownAnalyzer { JetType expectedType; PropertySetterDescriptor setter = propertyDescriptor.getSetter(); if (setter != null) { - expectedType = setter.getUnsubstitutedReturnType(); + expectedType = setter.getReturnType(); } else { expectedType = propertyDescriptor.getInType(); @@ -889,7 +889,7 @@ public class TopDownAnalyzer { resolveFunctionBody(traceForMembers, (JetNamedFunction) declaration, (FunctionDescriptorImpl) descriptor, declaringScope); - assert descriptor.getUnsubstitutedReturnType() != null; + assert descriptor.getReturnType() != null; } } @@ -907,7 +907,7 @@ public class TopDownAnalyzer { typeInferrer.checkFunctionReturnType(declaringScope, function, functionDescriptor); } - assert functionDescriptor.getUnsubstitutedReturnType() != null; + assert functionDescriptor.getReturnType() != null; } diff --git a/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java b/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java index f9f505d4707..e3590f64ca8 100644 --- a/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java +++ b/idea/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java @@ -342,7 +342,7 @@ public class JetTypeInferrer { } public void checkFunctionReturnType(@NotNull JetScope outerScope, @NotNull JetDeclarationWithBody function, @NotNull FunctionDescriptor functionDescriptor) { - final JetType expectedReturnType = functionDescriptor.getUnsubstitutedReturnType(); + final JetType expectedReturnType = functionDescriptor.getReturnType(); JetScope functionInnerScope = FunctionDescriptorUtil.getFunctionInnerScope(outerScope, functionDescriptor, trace); checkFunctionReturnType(functionInnerScope, function, functionDescriptor, expectedReturnType); // Map typeMap = collectReturnedExpressionsWithTypes(outerScope, function, functionDescriptor, expectedReturnType); @@ -563,7 +563,7 @@ public class JetTypeInferrer { final FunctionDescriptor functionDescriptor = resolutionResult.getFunctionDescriptor(); checkGenericBoundsInAFunctionCall(call.getTypeArguments(), typeArguments, functionDescriptor); - return functionDescriptor.getUnsubstitutedReturnType(); + return functionDescriptor.getReturnType(); } } return null; @@ -1802,7 +1802,7 @@ public class JetTypeInferrer { private JetType checkIterableConvention(@NotNull JetType type, @NotNull ASTNode reportErrorsOn) { OverloadResolutionResult iteratorResolutionResult = services.resolveNoParametersFunction(type, context.scope, "iterator"); if (iteratorResolutionResult.isSuccess()) { - JetType iteratorType = iteratorResolutionResult.getFunctionDescriptor().getUnsubstitutedReturnType(); + JetType iteratorType = iteratorResolutionResult.getFunctionDescriptor().getReturnType(); boolean hasNextFunctionSupported = checkHasNextFunctionSupport(reportErrorsOn, iteratorType); boolean hasNextPropertySupported = checkHasNextPropertySupport(reportErrorsOn, iteratorType); if (hasNextFunctionSupported && hasNextPropertySupported && !ErrorUtils.isErrorType(iteratorType)) { @@ -1819,7 +1819,7 @@ public class JetTypeInferrer { } else if (nextResolutionResult.isNothing()) { context.trace.getErrorHandler().genericError(reportErrorsOn, "Loop range must have an 'iterator().next()' method"); } else { - return nextResolutionResult.getFunctionDescriptor().getUnsubstitutedReturnType(); + return nextResolutionResult.getFunctionDescriptor().getReturnType(); } } else { @@ -1839,7 +1839,7 @@ public class JetTypeInferrer { } else if (hasNextResolutionResult.isNothing()) { return false; } else { - JetType hasNextReturnType = hasNextResolutionResult.getFunctionDescriptor().getUnsubstitutedReturnType(); + JetType hasNextReturnType = hasNextResolutionResult.getFunctionDescriptor().getReturnType(); if (!isBoolean(hasNextReturnType)) { context.trace.getErrorHandler().genericError(reportErrorsOn, "The 'iterator().hasNext()' method of the loop range must return Boolean, but returns " + hasNextReturnType); } @@ -2152,7 +2152,7 @@ public class JetTypeInferrer { if (receiverType != null) { FunctionDescriptor functionDescriptor = services.lookupFunction(context.scope, expression.getOperationSign(), name, receiverType, Collections.emptyList(), true); if (functionDescriptor != null) { - JetType returnType = functionDescriptor.getUnsubstitutedReturnType(); + JetType returnType = functionDescriptor.getReturnType(); if (operationType == JetTokens.PLUSPLUS || operationType == JetTokens.MINUSMINUS) { if (semanticServices.getTypeChecker().isSubtypeOf(returnType, JetStandardClasses.getUnitType())) { result = JetStandardClasses.getUnitType(); @@ -2219,7 +2219,7 @@ public class JetTypeInferrer { context.scope, operationSign, "equals", leftType, Collections.singletonList(JetStandardClasses.getNullableAnyType()), false); if (equals != null) { - if (ensureBooleanResult(operationSign, name, equals.getUnsubstitutedReturnType())) { + if (ensureBooleanResult(operationSign, name, equals.getReturnType())) { ensureNonemptyIntersectionOfOperandTypes(expression); } } @@ -2359,7 +2359,7 @@ public class JetTypeInferrer { FunctionDescriptor functionDescriptor = services.lookupFunction(context.scope, expression, "get", receiverType, argumentTypes, true); if (functionDescriptor != null) { // checkNullSafety(receiverType, expression.getIndexExpressions().get(0).getNode(), functionDescriptor); - result = functionDescriptor.getUnsubstitutedReturnType(); + result = functionDescriptor.getReturnType(); } } } @@ -2403,7 +2403,7 @@ public class JetTypeInferrer { " Use '?.'-qualified call instead"); } - return functionDescriptor.getUnsubstitutedReturnType(); + return functionDescriptor.getReturnType(); } return null; } @@ -2587,7 +2587,7 @@ public class JetTypeInferrer { services.lookupFunction(scope, arrayAccessExpression, "set", receiverType, argumentTypes, true); FunctionDescriptor functionDescriptor = services.lookupFunction(scope, operationSign, "set", receiverType, argumentTypes, true); if (functionDescriptor != null) { - result = functionDescriptor.getUnsubstitutedReturnType(); + result = functionDescriptor.getReturnType(); } } diff --git a/idea/src/org/jetbrains/jet/resolve/DescriptorRenderer.java b/idea/src/org/jetbrains/jet/resolve/DescriptorRenderer.java index 6806da23dd7..f6a46d59fa4 100644 --- a/idea/src/org/jetbrains/jet/resolve/DescriptorRenderer.java +++ b/idea/src/org/jetbrains/jet/resolve/DescriptorRenderer.java @@ -202,14 +202,14 @@ public class DescriptorRenderer { renderName(descriptor, builder); builder.append("("); - for (Iterator iterator = descriptor.getUnsubstitutedValueParameters().iterator(); iterator.hasNext(); ) { + for (Iterator iterator = descriptor.getValueParameters().iterator(); iterator.hasNext(); ) { ValueParameterDescriptor parameterDescriptor = iterator.next(); parameterDescriptor.accept(subVisitor, builder); if (iterator.hasNext()) { builder.append(", "); } } - builder.append(") : ").append(escape(renderType(descriptor.getUnsubstitutedReturnType()))); + builder.append(") : ").append(escape(renderType(descriptor.getReturnType()))); return super.visitFunctionDescriptor(descriptor, builder); } diff --git a/idea/testData/codegen/classes/simpleBox.jet b/idea/testData/codegen/classes/simpleBox.jet new file mode 100644 index 00000000000..be95d012d51 --- /dev/null +++ b/idea/testData/codegen/classes/simpleBox.jet @@ -0,0 +1,8 @@ +class Box(t: T) { + var value = t +} + +fun box(): String { + val box: Box = Box(1) + return if (box.value == 1) "OK" else "fail" +} diff --git a/idea/tests/org/jetbrains/jet/codegen/ClassGenTest.java b/idea/tests/org/jetbrains/jet/codegen/ClassGenTest.java index 7c8560bb6fa..e04f1eacd94 100644 --- a/idea/tests/org/jetbrains/jet/codegen/ClassGenTest.java +++ b/idea/tests/org/jetbrains/jet/codegen/ClassGenTest.java @@ -103,4 +103,8 @@ public class ClassGenTest extends CodegenTestCase { public void testExceptionConstructor() throws Exception { blackBoxFile("classes/exceptionConstructor.jet"); } + + public void testSimpleBox() throws Exception { + blackBoxFile("classes/simpleBox.jet"); + } } diff --git a/idea/tests/org/jetbrains/jet/resolve/JetResolveTest.java b/idea/tests/org/jetbrains/jet/resolve/JetResolveTest.java index d74f13dd69c..32b084a67a6 100644 --- a/idea/tests/org/jetbrains/jet/resolve/JetResolveTest.java +++ b/idea/tests/org/jetbrains/jet/resolve/JetResolveTest.java @@ -104,7 +104,7 @@ public class JetResolveTest extends ExtensibleResolveTestCase { List parameterTypeList = Arrays.asList(parameterType); OverloadResolutionResult functions = functionGroup.getPossiblyApplicableFunctions(Collections.emptyList(), parameterTypeList); for (FunctionDescriptor function : functions.getFunctionDescriptors()) { - List unsubstitutedValueParameters = function.getUnsubstitutedValueParameters(); + List unsubstitutedValueParameters = function.getValueParameters(); for (int i = 0, unsubstitutedValueParametersSize = unsubstitutedValueParameters.size(); i < unsubstitutedValueParametersSize; i++) { ValueParameterDescriptor unsubstitutedValueParameter = unsubstitutedValueParameters.get(i); if (unsubstitutedValueParameter.getOutType().equals(parameterType[i])) {