assorted fixes to handle boxing correctly when calling generic...

assorted fixes to handle boxing correctly when calling generic methods/properties; rename getUnsubstitutedValueParameters/ReturnType to getValueParameters/ReturnType

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<ValueParameterDescriptor> parameters = funDescriptor.getUnsubstitutedValueParameters();
+        final List<ValueParameterDescriptor> 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<JetElement> 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<ValueParameterDescriptor> params = funDescriptor.getUnsubstitutedValueParameters();
+        final List<ValueParameterDescriptor> 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;
         }

idea/src/org/jetbrains/jet/codegen/ConstructorFrameMap.java

@@ -52,7 +52,7 @@ public class ConstructorFrameMap extends FrameMap {
         }
 
         List<ValueParameterDescriptor> paramDescrs = descriptor != null
-                ? descriptor.getUnsubstitutedValueParameters()
+                ? descriptor.getValueParameters()
                 : Collections.<ValueParameterDescriptor>emptyList();
         for (int i = 0; i < paramDescrs.size(); i++) {
             ValueParameterDescriptor parameter = paramDescrs.get(i);

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<ValueParameterDescriptor> parameters = constructorDescriptor.getUnsubstitutedValueParameters();
+                        List<ValueParameterDescriptor> 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) {

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<ValueParameterDescriptor> paramDescrs = state.getBindingContext().getFunctionDescriptor(f).getUnsubstitutedValueParameters();
+        List<ValueParameterDescriptor> paramDescrs = state.getBindingContext().getFunctionDescriptor(f).getValueParameters();
         generateMethod(f, kind, method, receiverType, paramDescrs);
     }
 

idea/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java

@@ -99,7 +99,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
 
         Type[] argTypes = method.getArgumentTypes();
         List<ValueParameterDescriptor> paramDescrs = constructorDescriptor != null
-                ? constructorDescriptor.getUnsubstitutedValueParameters()
+                ? constructorDescriptor.getValueParameters()
                 : Collections.<ValueParameterDescriptor>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<ValueParameterDescriptor> valueParameters = constructorDescriptor.getUnsubstitutedValueParameters();
+        List<ValueParameterDescriptor> valueParameters = constructorDescriptor.getValueParameters();
         List<JetArgument> args = constructorCall.getValueArguments();
         for (int i = 0, argsSize = args.size(); i < argsSize; i++) {
             JetArgument arg = args.get(i);

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<ValueParameterDescriptor> parameters = f.getUnsubstitutedValueParameters();
+        final List<ValueParameterDescriptor> parameters = f.getValueParameters();
         List<Type> parameterTypes = new ArrayList<Type>();
         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<ValueParameterDescriptor> parameters = descriptor.getUnsubstitutedValueParameters();
+        List<ValueParameterDescriptor> parameters = descriptor.getOriginal().getValueParameters();
         List<Type> parameterTypes = new ArrayList<Type>();
         ClassDescriptor classDescriptor = descriptor.getContainingDeclaration();
         final DeclarationDescriptor outerDescriptor = classDescriptor.getContainingDeclaration();

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);

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

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

idea/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptor.java

@@ -23,10 +23,10 @@ public interface FunctionDescriptor extends DeclarationDescriptor {
     List<TypeParameterDescriptor> getTypeParameters();
 
     @NotNull
-    List<ValueParameterDescriptor> getUnsubstitutedValueParameters();
+    List<ValueParameterDescriptor> getValueParameters();
 
     @NotNull
-    JetType getUnsubstitutedReturnType();
+    JetType getReturnType();
 
     @NotNull
     FunctionDescriptor getOriginal();

idea/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorImpl.java

@@ -79,13 +79,13 @@ public class FunctionDescriptorImpl extends DeclarationDescriptorImpl implements
 
     @Override
     @NotNull
-    public List<ValueParameterDescriptor> getUnsubstitutedValueParameters() {
+    public List<ValueParameterDescriptor> getValueParameters() {
         return unsubstitutedValueParameters;
     }
 
     @Override
     @NotNull
-    public JetType getUnsubstitutedReturnType() {
+    public JetType getReturnType() {
         return unsubstitutedReturnType;
     }
 

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<ValueParameterDescriptor> unsubstitutedValueParameters = functionDescriptor.getUnsubstitutedValueParameters();
+        List<ValueParameterDescriptor> unsubstitutedValueParameters = functionDescriptor.getValueParameters();
         if (unsubstitutedValueParameters.isEmpty()) {
             return 0;
         }
@@ -65,7 +65,7 @@ public class FunctionDescriptorUtil {
     @Nullable
     public static List<ValueParameterDescriptor> getSubstitutedValueParameters(FunctionDescriptor substitutedDescriptor, @NotNull FunctionDescriptor functionDescriptor, TypeSubstitutor substitutor) {
         List<ValueParameterDescriptor> result = new ArrayList<ValueParameterDescriptor>();
-        List<ValueParameterDescriptor> unsubstitutedValueParameters = functionDescriptor.getUnsubstitutedValueParameters();
+        List<ValueParameterDescriptor> 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<ValueParameterDescriptor> superValueParameters = superFunction.getUnsubstitutedValueParameters();
-        List<ValueParameterDescriptor> subValueParameters = subFunction.getUnsubstitutedValueParameters();
+        List<ValueParameterDescriptor> superValueParameters = superFunction.getValueParameters();
+        List<ValueParameterDescriptor> 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();

idea/src/org/jetbrains/jet/lang/descriptors/PropertyGetterDescriptor.java

@@ -38,13 +38,13 @@ public class PropertyGetterDescriptor extends PropertyAccessorDescriptor {
 
     @NotNull
     @Override
-    public List<ValueParameterDescriptor> getUnsubstitutedValueParameters() {
+    public List<ValueParameterDescriptor> getValueParameters() {
         return Collections.emptyList();
     }
 
     @NotNull
     @Override
-    public JetType getUnsubstitutedReturnType() {
+    public JetType getReturnType() {
         return returnType;
     }
 

idea/src/org/jetbrains/jet/lang/descriptors/PropertySetterDescriptor.java

@@ -47,13 +47,13 @@ public class PropertySetterDescriptor extends PropertyAccessorDescriptor {
 
     @NotNull
     @Override
-    public List<ValueParameterDescriptor> getUnsubstitutedValueParameters() {
+    public List<ValueParameterDescriptor> getValueParameters() {
         return Collections.<ValueParameterDescriptor>singletonList(parameter);
     }
 
     @NotNull
     @Override
-    public JetType getUnsubstitutedReturnType() {
+    public JetType getReturnType() {
         return JetStandardClasses.getUnitType();
     }
 

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<ValueParameterDescriptor, String>() {
+                tailText = "(" + StringUtil.join(functionDescriptor.getValueParameters(), new Function<ValueParameterDescriptor, String>() {
                     @Override
                     public String fun(ValueParameterDescriptor valueParameterDescriptor) {
                         return valueParameterDescriptor.getName() + ":" +

idea/src/org/jetbrains/jet/lang/resolve/OverloadResolver.java

@@ -75,7 +75,7 @@ public class OverloadResolver {
                         continue;
                     }
 
-                    List<ValueParameterDescriptor> parameters = descriptor.getUnsubstitutedValueParameters();
+                    List<ValueParameterDescriptor> 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<ValueParameterDescriptor> fParams = f.getUnsubstitutedValueParameters();
-        List<ValueParameterDescriptor> gParams = g.getUnsubstitutedValueParameters();
+        List<ValueParameterDescriptor> fParams = f.getValueParameters();
+        List<ValueParameterDescriptor> gParams = g.getValueParameters();
 
         int fSize = fParams.size();
         if (fSize != gParams.size()) return false;

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;
     }
 
 

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<JetElement, JetType> 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.<JetType>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();
             }
         }
 

idea/src/org/jetbrains/jet/resolve/DescriptorRenderer.java

@@ -202,14 +202,14 @@ public class DescriptorRenderer {
 
             renderName(descriptor, builder);
             builder.append("(");
-            for (Iterator<ValueParameterDescriptor> iterator = descriptor.getUnsubstitutedValueParameters().iterator(); iterator.hasNext(); ) {
+            for (Iterator<ValueParameterDescriptor> 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);
         }
 

idea/testData/codegen/classes/simpleBox.jet

+class Box<T>(t: T) {
+    var value = t
+}
+
+fun box(): String {
+    val box: Box<Int> = Box<Int>(1)
+    return if (box.value == 1) "OK" else "fail"
+}

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");
+    }
 }

idea/tests/org/jetbrains/jet/resolve/JetResolveTest.java

@@ -104,7 +104,7 @@ public class JetResolveTest extends ExtensibleResolveTestCase {
         List<JetType> parameterTypeList = Arrays.asList(parameterType);
         OverloadResolutionResult functions = functionGroup.getPossiblyApplicableFunctions(Collections.<JetType>emptyList(), parameterTypeList);
         for (FunctionDescriptor function : functions.getFunctionDescriptors()) {
-            List<ValueParameterDescriptor> unsubstitutedValueParameters = function.getUnsubstitutedValueParameters();
+            List<ValueParameterDescriptor> unsubstitutedValueParameters = function.getValueParameters();
             for (int i = 0, unsubstitutedValueParametersSize = unsubstitutedValueParameters.size(); i < unsubstitutedValueParametersSize; i++) {
                 ValueParameterDescriptor unsubstitutedValueParameter = unsubstitutedValueParameters.get(i);
                 if (unsubstitutedValueParameter.getOutType().equals(parameterType[i])) {