diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ClassBodyCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ClassBodyCodegen.java index 6c9083f4098..c6275166cea 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ClassBodyCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ClassBodyCodegen.java @@ -119,7 +119,7 @@ public abstract class ClassBodyCodegen { if(state.getStandardLibrary().isVolatile(propertyDescriptor)) { modifiers |= Opcodes.ACC_VOLATILE; } - v.newField(p, modifiers, p.getName(), state.getTypeMapper().mapType(propertyDescriptor.getOutType()).getDescriptor(), null, null); + v.newField(p, modifiers, p.getName(), state.getTypeMapper().mapType(propertyDescriptor.getType()).getDescriptor(), null, null); } } } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ClosureCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ClosureCodegen.java index 675ab801145..d49fc46fc50 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ClosureCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ClosureCodegen.java @@ -113,7 +113,7 @@ public class ClosureCodegen extends ObjectOrClosureCodegen { final String funClass = getInternalClassName(funDescriptor); signatureWriter.visitClassType(funClass); for (ValueParameterDescriptor parameter : parameters) { - appendType(signatureWriter, parameter.getOutType(), '='); + appendType(signatureWriter, parameter.getType(), '='); } appendType(signatureWriter, funDescriptor.getReturnType(), '='); @@ -233,7 +233,7 @@ public class ClosureCodegen extends ObjectOrClosureCodegen { 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); + StackValue.onStack(JetTypeMapper.TYPE_OBJECT).upcast(state.getTypeMapper().mapType(param.getType()), iv); count++; } @@ -280,7 +280,7 @@ public class ClosureCodegen extends ObjectOrClosureCodegen { for (DeclarationDescriptor descriptor : closure.keySet()) { if(descriptor instanceof VariableDescriptor && !(descriptor instanceof PropertyDescriptor)) { final Type sharedVarType = exprContext.getTypeMapper().getSharedVarType(descriptor); - final Type type = sharedVarType != null ? sharedVarType : state.getTypeMapper().mapType(((VariableDescriptor) descriptor).getOutType()); + final Type type = sharedVarType != null ? sharedVarType : state.getTypeMapper().mapType(((VariableDescriptor) descriptor).getType()); argTypes[i++] = type; } else if(CodegenUtil.isNamedFun(descriptor, state.getBindingContext()) && descriptor.getContainingDeclaration() instanceof FunctionDescriptor) { diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/CodegenContext.java b/compiler/backend/src/org/jetbrains/jet/codegen/CodegenContext.java index c8745e1ab98..9f203fc1ee2 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/CodegenContext.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/CodegenContext.java @@ -230,12 +230,12 @@ public abstract class CodegenContext { if(accessor != null) return accessor; - if(descriptor instanceof NamedFunctionDescriptor) { - NamedFunctionDescriptorImpl myAccessor = new NamedFunctionDescriptorImpl(contextType, + if(descriptor instanceof SimpleFunctionDescriptor) { + SimpleFunctionDescriptorImpl myAccessor = new SimpleFunctionDescriptorImpl(contextType, Collections.emptyList(), descriptor.getName() + "$bridge$" + accessors.size(), CallableMemberDescriptor.Kind.DECLARATION); - FunctionDescriptor fd = (NamedFunctionDescriptor) descriptor; + FunctionDescriptor fd = (SimpleFunctionDescriptor) descriptor; myAccessor.initialize(fd.getReceiverParameter().exists() ? fd.getReceiverParameter().getType() : null, fd.getExpectedThisObject(), fd.getTypeParameters(), @@ -257,13 +257,13 @@ public abstract class CodegenContext { CallableMemberDescriptor.Kind.DECLARATION ); JetType receiverType = pd.getReceiverParameter().exists() ? pd.getReceiverParameter().getType() : null; - myAccessor.setType(pd.getOutType(), Collections.emptyList(), pd.getExpectedThisObject(), receiverType); + myAccessor.setType(pd.getType(), Collections.emptyList(), pd.getExpectedThisObject(), receiverType); PropertyGetterDescriptor pgd = new PropertyGetterDescriptor( myAccessor, Collections.emptyList(), myAccessor.getModality(), myAccessor.getVisibility(), false, false, CallableMemberDescriptor.Kind.DECLARATION); - pgd.initialize(myAccessor.getOutType()); + pgd.initialize(myAccessor.getType()); PropertySetterDescriptor psd = new PropertySetterDescriptor( myAccessor, Collections.emptyList(), myAccessor.getModality(), diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/CodegenUtil.java b/compiler/backend/src/org/jetbrains/jet/codegen/CodegenUtil.java index 4edfd8396f0..55ca8a33101 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/CodegenUtil.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/CodegenUtil.java @@ -74,9 +74,9 @@ public class CodegenUtil { return (ClassDescriptor) outerDescriptor; } - public static NamedFunctionDescriptor createInvoke(FunctionDescriptor fd) { + public static SimpleFunctionDescriptor createInvoke(FunctionDescriptor fd) { int arity = fd.getValueParameters().size(); - NamedFunctionDescriptorImpl invokeDescriptor = new NamedFunctionDescriptorImpl( + SimpleFunctionDescriptorImpl invokeDescriptor = new SimpleFunctionDescriptorImpl( fd.getExpectedThisObject().exists() ? JetStandardClasses.getReceiverFunction(arity) : JetStandardClasses.getFunction(arity), Collections.emptyList(), "invoke", diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java index b93a5f47185..7fb90fc8eb0 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java @@ -17,7 +17,6 @@ package org.jetbrains.jet.codegen; import com.intellij.openapi.editor.Document; -import com.intellij.psi.PsiClass; import com.intellij.psi.PsiElement; import com.intellij.psi.PsiMethod; import com.intellij.psi.tree.IElementType; @@ -31,8 +30,6 @@ import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.calls.*; import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant; -import org.jetbrains.jet.lang.resolve.java.JvmAbi; -import org.jetbrains.jet.lang.resolve.java.JvmStdlibNames; import org.jetbrains.jet.lang.resolve.scopes.receivers.ClassReceiver; import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver; import org.jetbrains.jet.lang.resolve.scopes.receivers.ExtensionReceiver; @@ -356,7 +353,7 @@ public class ExpressionCodegen extends JetVisitor { JetType iteratorType = iteratorDescriptor.getReturnType(); Type asmIterType = boxType(asmType(iteratorType)); - JetType paramType = parameterDescriptor.getOutType(); + JetType paramType = parameterDescriptor.getType(); Type asmParamType = asmType(paramType); int iteratorVar = myFrameMap.enterTemp(); @@ -431,7 +428,7 @@ public class ExpressionCodegen extends JetVisitor { } public void invoke() { - JetType paramType = parameterDescriptor.getOutType(); + JetType paramType = parameterDescriptor.getType(); Type asmParamType = asmType(paramType); myFrameMap.enter(parameterDescriptor, asmParamType.getSize()); @@ -804,7 +801,7 @@ public class ExpressionCodegen extends JetVisitor { if(entry.getKey() instanceof VariableDescriptor && !(entry.getKey() instanceof PropertyDescriptor)) { Type sharedVarType = typeMapper.getSharedVarType(entry.getKey()); if(sharedVarType == null) - sharedVarType = state.getTypeMapper().mapType(((VariableDescriptor) entry.getKey()).getOutType()); + sharedVarType = state.getTypeMapper().mapType(((VariableDescriptor) entry.getKey()).getType()); consArgTypes.add(sharedVarType); entry.getValue().getOuterValue().put(sharedVarType, v); } @@ -836,7 +833,7 @@ public class ExpressionCodegen extends JetVisitor { assert variableDescriptor != null; final Type sharedVarType = typeMapper.getSharedVarType(variableDescriptor); - final Type type = sharedVarType != null ? sharedVarType : asmType(variableDescriptor.getOutType()); + final Type type = sharedVarType != null ? sharedVarType : asmType(variableDescriptor.getType()); myFrameMap.enter(variableDescriptor, type.getSize()); } @@ -877,7 +874,7 @@ public class ExpressionCodegen extends JetVisitor { int index = myFrameMap.leave(variableDescriptor); final Type sharedVarType = typeMapper.getSharedVarType(variableDescriptor); - final Type type = sharedVarType != null ? sharedVarType : asmType(variableDescriptor.getOutType()); + final Type type = sharedVarType != null ? sharedVarType : asmType(variableDescriptor.getType()); if(sharedVarType != null) { v.aconst(null); v.store(index, TYPE_OBJECT); @@ -986,7 +983,7 @@ public class ExpressionCodegen extends JetVisitor { if (index >= 0) { if(descriptor instanceof VariableDescriptor) { Type sharedVarType = typeMapper.getSharedVarType(descriptor); - final JetType outType = ((VariableDescriptor) descriptor).getOutType(); + final JetType outType = ((VariableDescriptor) descriptor).getType(); if(sharedVarType != null) { return StackValue.shared(index, asmType(outType)); } @@ -1234,7 +1231,7 @@ public class ExpressionCodegen extends JetVisitor { ownerParam = callableMethod.getDefaultImplParam(); } - return StackValue.property(propertyDescriptor.getName(), owner, ownerParam, asmType(propertyDescriptor.getOutType()), isStatic, isInterface, isSuper, getter, setter, invokeOpcode); + return StackValue.property(propertyDescriptor.getName(), owner, ownerParam, asmType(propertyDescriptor.getType()), isStatic, isInterface, isSuper, getter, setter, invokeOpcode); } @Override @@ -1246,11 +1243,11 @@ public class ExpressionCodegen extends JetVisitor { if(resolvedCall == null) { throw new CompilationException("Cannot resolve: " + callee.getText(), null, expression); } - receiver = StackValue.receiver(resolvedCall, receiver, this, null); DeclarationDescriptor funDescriptor = resolvedCall.getResultingDescriptor(); if (funDescriptor instanceof ConstructorDescriptor) { + receiver = StackValue.receiver(resolvedCall, receiver, this, null); return generateConstructorCall(expression, (JetSimpleNameExpression) callee, receiver); } else if (funDescriptor instanceof FunctionDescriptor) { @@ -1295,6 +1292,10 @@ public class ExpressionCodegen extends JetVisitor { return returnValueAsStackValue((FunctionDescriptor) fd, callReturnType); } else { + ResolvedCall resolvedCall = bindingContext.get(BindingContext.RESOLVED_CALL, expression.getCalleeExpression()); + assert resolvedCall != null; + receiver = StackValue.receiver(resolvedCall, receiver, this, null); + IntrinsicMethod intrinsic = (IntrinsicMethod) callable; List args = new ArrayList(); for (ValueArgument argument : expression.getValueArguments()) { @@ -1324,8 +1325,8 @@ public class ExpressionCodegen extends JetVisitor { assert !superCall; callableMethod = ClosureCodegen.asCallableMethod((FunctionDescriptor) fd); } - else if (fd instanceof ExpressionAsFunctionDescriptor || (fd instanceof NamedFunctionDescriptor && fd.getContainingDeclaration() instanceof FunctionDescriptor)) { - NamedFunctionDescriptor invoke = CodegenUtil.createInvoke((FunctionDescriptor) fd); + else if (fd instanceof ExpressionAsFunctionDescriptor || (fd instanceof SimpleFunctionDescriptor && fd.getContainingDeclaration() instanceof FunctionDescriptor)) { + SimpleFunctionDescriptor invoke = CodegenUtil.createInvoke((FunctionDescriptor) fd); callableMethod = ClosureCodegen.asCallableMethod(invoke); } else if (fd instanceof FunctionDescriptor) { @@ -1510,7 +1511,7 @@ public class ExpressionCodegen extends JetVisitor { } else if(resolvedValueArgument instanceof VarargValueArgument) { VarargValueArgument valueArgument = (VarargValueArgument) resolvedValueArgument; - JetType outType = valueParameterDescriptor.getOutType(); + JetType outType = valueParameterDescriptor.getType(); Type type = asmType(outType); assert type.getSort() == Type.ARRAY; @@ -1681,7 +1682,7 @@ public class ExpressionCodegen extends JetVisitor { StackValue leftValue = gen(expr); FunctionDescriptor op = (FunctionDescriptor) bindingContext.get(BindingContext.REFERENCE_TARGET, expression.getOperationReference()); assert op != null; - leftValue.put(asmType(op.getValueParameters().get(0).getOutType()), v); + leftValue.put(asmType(op.getValueParameters().get(0).getType()), v); genToJVMStack(expression.getRight()); v.swap(); invokeFunctionNoParams(op, Type.BOOLEAN_TYPE, v); @@ -2208,7 +2209,7 @@ public class ExpressionCodegen extends JetVisitor { final Type sharedVarType = typeMapper.getSharedVarType(variableDescriptor); assert variableDescriptor != null; - Type varType = asmType(variableDescriptor.getOutType()); + Type varType = asmType(variableDescriptor.getType()); if(sharedVarType != null) { v.anew(sharedVarType); v.dup(); @@ -2370,7 +2371,7 @@ public class ExpressionCodegen extends JetVisitor { final List indices = expression.getIndexExpressions(); FunctionDescriptor operationDescriptor = (FunctionDescriptor) bindingContext.get(BindingContext.REFERENCE_TARGET, expression); assert operationDescriptor != null; - if (arrayType.getSort() == Type.ARRAY && indices.size() == 1 && operationDescriptor.getValueParameters().get(0).getOutType().equals(state.getStandardLibrary().getIntType())) { + if (arrayType.getSort() == Type.ARRAY && indices.size() == 1 && operationDescriptor.getValueParameters().get(0).getType().equals(state.getStandardLibrary().getIntType())) { gen(array, arrayType); for (JetExpression index : indices) { gen(index, Type.INT_TYPE); @@ -2498,7 +2499,7 @@ If finally block is present, its last expression is the value of try expression. VariableDescriptor descriptor = bindingContext.get(BindingContext.VALUE_PARAMETER, clause.getCatchParameter()); assert descriptor != null; - Type descriptorType = asmType(descriptor.getOutType()); + Type descriptorType = asmType(descriptor.getType()); myFrameMap.enter(descriptor, 1); int index = lookupLocal(descriptor); v.store(index, descriptorType); @@ -2613,7 +2614,7 @@ If finally block is present, its last expression is the value of try expression. final JetProperty var = ((JetBindingPattern) pattern).getVariableDeclaration(); final VariableDescriptor variableDescriptor = bindingContext.get(BindingContext.VARIABLE, var); assert variableDescriptor != null; - final Type varType = asmType(variableDescriptor.getOutType()); + final Type varType = asmType(variableDescriptor.getType()); myFrameMap.enter(variableDescriptor, varType.getSize()); expressionToMatch.dupReceiver(v); expressionToMatch.put(varType, v); diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java index 90dfd5ae47c..579071d2de4 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java @@ -56,7 +56,7 @@ public class FunctionCodegen { } public void gen(JetNamedFunction f) { - final NamedFunctionDescriptor functionDescriptor = state.getBindingContext().get(BindingContext.FUNCTION, f); + final SimpleFunctionDescriptor functionDescriptor = state.getBindingContext().get(BindingContext.FUNCTION, f); assert functionDescriptor != null; JvmMethodSignature method = typeMapper.mapToCallableMethod(functionDescriptor, false, owner.getContextKind()).getSignature(); generateMethod(f, method, true, null, functionDescriptor); @@ -120,7 +120,7 @@ public class FunctionCodegen { if (needJetAnnotations) { if (functionDescriptor instanceof PropertyAccessorDescriptor) { PropertyCodegen.generateJetPropertyAnnotation(mv, propertyTypeSignature, jvmSignature.getKotlinTypeParameter()); - } else if (functionDescriptor instanceof NamedFunctionDescriptor) { + } else if (functionDescriptor instanceof SimpleFunctionDescriptor) { if (propertyTypeSignature != null) { throw new IllegalStateException(); } @@ -153,7 +153,7 @@ public class FunctionCodegen { if(parameterDescriptor.hasDefaultValue()) { av.visit(JvmStdlibNames.JET_VALUE_PARAMETER_HAS_DEFAULT_VALUE_FIELD, true); } - if(parameterDescriptor.getOutType().isNullable()) { + if(parameterDescriptor.getType().isNullable()) { av.visit(JvmStdlibNames.JET_VALUE_PARAMETER_NULLABLE_FIELD, true); } if (jvmSignature.getKotlinParameterTypes() != null && jvmSignature.getKotlinParameterTypes().get(i) != null) { @@ -205,7 +205,7 @@ public class FunctionCodegen { for (ValueParameterDescriptor parameter : paramDescrs) { Type sharedVarType = typeMapper.getSharedVarType(parameter); if (sharedVarType != null) { - Type localVarType = typeMapper.mapType(parameter.getOutType()); + Type localVarType = typeMapper.mapType(parameter.getType()); int index = frameMap.getIndex(parameter); mv.visitTypeInsn(NEW, sharedVarType.getInternalName()); mv.visitInsn(DUP); @@ -239,7 +239,7 @@ public class FunctionCodegen { } for (ValueParameterDescriptor parameter : paramDescrs) { - Type type = typeMapper.mapType(parameter.getOutType()); + Type type = typeMapper.mapType(parameter.getType()); // TODO: specify signature mv.visitLocalVariable(parameter.getName(), type.getDescriptor(), null, methodBegin, methodEnd, k); k += type.getSize(); diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java index cf73bd81bff..efd53abd0c5 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java @@ -29,7 +29,6 @@ import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant; import org.jetbrains.jet.lang.resolve.java.JvmAbi; import org.jetbrains.jet.lang.resolve.java.JvmStdlibNames; import org.jetbrains.jet.lang.types.JetType; -import org.jetbrains.jet.lang.types.TypeProjection; import org.jetbrains.jet.lexer.JetTokens; import org.objectweb.asm.AnnotationVisitor; import org.objectweb.asm.MethodVisitor; @@ -452,7 +451,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { for (DeclarationDescriptor descriptor : closure.closure.keySet()) { if(descriptor instanceof VariableDescriptor && !(descriptor instanceof PropertyDescriptor)) { final Type sharedVarType = typeMapper.getSharedVarType(descriptor); - final Type type = sharedVarType != null ? sharedVarType : state.getTypeMapper().mapType(((VariableDescriptor) descriptor).getOutType()); + final Type type = sharedVarType != null ? sharedVarType : state.getTypeMapper().mapType(((VariableDescriptor) descriptor).getType()); consArgTypes.add(insert++, new JvmMethodParameterSignature(type, "", JvmMethodParameterKind.SHARED_VAR)); } else if(descriptor instanceof FunctionDescriptor) { @@ -533,7 +532,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { HashSet overridden = new HashSet(); for (JetDeclaration declaration : myClass.getDeclarations()) { if (declaration instanceof JetNamedFunction) { - NamedFunctionDescriptor functionDescriptor = bindingContext.get(BindingContext.FUNCTION, declaration); + SimpleFunctionDescriptor functionDescriptor = bindingContext.get(BindingContext.FUNCTION, declaration); assert functionDescriptor != null; overridden.addAll(functionDescriptor.getOverriddenDescriptors()); } @@ -613,7 +612,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { if(varDescr instanceof VariableDescriptor && !(varDescr instanceof PropertyDescriptor)) { Type sharedVarType = typeMapper.getSharedVarType(varDescr); if(sharedVarType == null) { - sharedVarType = typeMapper.mapType(((VariableDescriptor) varDescr).getOutType()); + sharedVarType = typeMapper.mapType(((VariableDescriptor) varDescr).getType()); } iv.load(0, JetTypeMapper.TYPE_OBJECT); iv.load(k, StackValue.refType(sharedVarType)); @@ -629,7 +628,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { for (JetParameter parameter : constructorParameters) { if (parameter.getValOrVarNode() != null) { VariableDescriptor descriptor = paramDescrs.get(curParam); - Type type = typeMapper.mapType(descriptor.getOutType()); + Type type = typeMapper.mapType(descriptor.getType()); iv.load(0, classType); iv.load(frameMap.getIndex(descriptor), type); iv.putfield(classname, descriptor.getName(), type.getDescriptor()); @@ -653,7 +652,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { for (Pair needDelegates : getTraitImplementations(descriptor)) { CallableMemberDescriptor callableDescriptor = needDelegates.first; - if (needDelegates.second instanceof NamedFunctionDescriptor) { + if (needDelegates.second instanceof SimpleFunctionDescriptor) { generateDelegationToTraitImpl(codegen, (FunctionDescriptor) needDelegates.second); } else if (needDelegates.second instanceof PropertyDescriptor) { PropertyDescriptor property = (PropertyDescriptor) needDelegates.second; @@ -865,9 +864,9 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { if(compileTimeValue != null) { assert compileTimeValue != null; Object value = compileTimeValue.getValue(); - Type type = typeMapper.mapType(propertyDescriptor.getOutType()); + Type type = typeMapper.mapType(propertyDescriptor.getType()); if(JetTypeMapper.isPrimitive(type)) { - if( !propertyDescriptor.getOutType().isNullable() && value instanceof Number) { + if( !propertyDescriptor.getType().isNullable() && value instanceof Number) { if(type == Type.INT_TYPE && ((Number)value).intValue() == 0) continue; if(type == Type.BYTE_TYPE && ((Number)value).byteValue() == 0) @@ -893,12 +892,12 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { } iv.load(0, JetTypeMapper.TYPE_OBJECT); Type type = codegen.expressionType(initializer); - if(propertyDescriptor.getOutType().isNullable()) + if(propertyDescriptor.getType().isNullable()) type = JetTypeMapper.boxType(type); codegen.gen(initializer, type); // @todo write directly to the field. Fix test excloset.jet::test6 String owner = typeMapper.getOwner(propertyDescriptor, OwnerKind.IMPLEMENTATION); - StackValue.property(propertyDescriptor.getName(), owner, owner, typeMapper.mapType(propertyDescriptor.getOutType()), false, false, false, null, null, 0).store(iv); + StackValue.property(propertyDescriptor.getName(), owner, owner, typeMapper.mapType(propertyDescriptor.getType()), false, false, false, null, null, 0).store(iv); } } @@ -924,8 +923,8 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { if (declaration instanceof PropertyDescriptor) { propertyCodegen.genDelegate((PropertyDescriptor) declaration, (PropertyDescriptor) overriddenDescriptor, field); } - else if (declaration instanceof NamedFunctionDescriptor) { - functionCodegen.genDelegate((NamedFunctionDescriptor) declaration, overriddenDescriptor, field); + else if (declaration instanceof SimpleFunctionDescriptor) { + functionCodegen.genDelegate((SimpleFunctionDescriptor) declaration, overriddenDescriptor, field); } } } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java b/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java index 4ab7089bfad..4221e4d5566 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java @@ -488,7 +488,7 @@ public class JetTypeMapper { for (ValueParameterDescriptor parameter : parameters) { signatureVisitor.writeParameterType(JvmMethodParameterKind.VALUE); - mapType(parameter.getOutType(), signatureVisitor); + mapType(parameter.getType(), signatureVisitor); signatureVisitor.writeParameterTypeEnd(); } @@ -576,7 +576,7 @@ public class JetTypeMapper { } for (ValueParameterDescriptor parameter : parameters) { signatureWriter.writeParameterType(JvmMethodParameterKind.VALUE); - mapType(parameter.getOutType(), signatureWriter); + mapType(parameter.getType(), signatureWriter); signatureWriter.writeParameterTypeEnd(); } @@ -617,7 +617,7 @@ public class JetTypeMapper { signatureWriter.writeParametersEnd(); signatureWriter.writeReturnType(); - mapType(descriptor.getOutType(), signatureWriter); + mapType(descriptor.getType(), signatureWriter); signatureWriter.writeReturnTypeEnd(); JvmMethodSignature jvmMethodSignature = signatureWriter.makeJvmMethodSignature(name); @@ -636,7 +636,7 @@ public class JetTypeMapper { writeFormalTypeParameters(descriptor.getTypeParameters(), signatureWriter); - JetType outType = descriptor.getOutType(); + JetType outType = descriptor.getType(); signatureWriter.writeParametersStart(); @@ -687,7 +687,7 @@ public class JetTypeMapper { for (ValueParameterDescriptor parameter : parameters) { signatureWriter.writeParameterType(JvmMethodParameterKind.VALUE); - mapType(parameter.getOutType(), signatureWriter); + mapType(parameter.getType(), signatureWriter); signatureWriter.writeParameterTypeEnd(); } @@ -854,7 +854,7 @@ public class JetTypeMapper { if(descriptor instanceof PropertyDescriptor) { return StackValue.sharedTypeForType(mapType(((PropertyDescriptor) descriptor).getReceiverParameter().getType())); } - else if (descriptor instanceof NamedFunctionDescriptor && descriptor.getContainingDeclaration() instanceof FunctionDescriptor) { + else if (descriptor instanceof SimpleFunctionDescriptor && descriptor.getContainingDeclaration() instanceof FunctionDescriptor) { PsiElement psiElement = bindingContext.get(BindingContext.DESCRIPTOR_TO_DECLARATION, descriptor); return Type.getObjectType(classNameForAnonymousClass((JetElement) psiElement)); } @@ -864,7 +864,7 @@ public class JetTypeMapper { else if (descriptor instanceof VariableDescriptor) { Boolean aBoolean = bindingContext.get(BindingContext.MUST_BE_WRAPPED_IN_A_REF, (VariableDescriptor) descriptor); if (aBoolean != null && aBoolean) { - JetType outType = ((VariableDescriptor) descriptor).getOutType(); + JetType outType = ((VariableDescriptor) descriptor).getType(); return StackValue.sharedTypeForType(mapType(outType)); } else { diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ObjectOrClosureCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ObjectOrClosureCodegen.java index 4129668524a..69203c98bd9 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ObjectOrClosureCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ObjectOrClosureCodegen.java @@ -61,7 +61,7 @@ public class ObjectOrClosureCodegen { if (idx < 0) return null; final Type sharedVarType = state.getTypeMapper().getSharedVarType(vd); - Type localType = state.getTypeMapper().mapType(vd.getOutType()); + Type localType = state.getTypeMapper().mapType(vd.getType()); final Type type = sharedVarType != null ? sharedVarType : localType; StackValue outerValue = StackValue.local(idx, type); diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/PropertyCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/PropertyCodegen.java index 4d7e484b410..5710b95ee5e 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/PropertyCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/PropertyCodegen.java @@ -30,10 +30,6 @@ import org.objectweb.asm.MethodVisitor; import org.objectweb.asm.Opcodes; import org.objectweb.asm.Type; import org.objectweb.asm.commons.InstructionAdapter; -import org.objectweb.asm.commons.Method; - -import static org.objectweb.asm.Opcodes.ACC_PUBLIC; -import static org.objectweb.asm.Opcodes.ACC_SYNTHETIC; /** * @author max @@ -99,7 +95,7 @@ public class PropertyCodegen { if(state.getStandardLibrary().isVolatile(propertyDescriptor)) { modifiers |= Opcodes.ACC_VOLATILE; } - FieldVisitor fieldVisitor = v.newField(p, modifiers, p.getName(), state.getTypeMapper().mapType(propertyDescriptor.getOutType()).getDescriptor(), null, value); + FieldVisitor fieldVisitor = v.newField(p, modifiers, p.getName(), state.getTypeMapper().mapType(propertyDescriptor.getType()).getDescriptor(), null, value); AnnotationCodegen.forField(fieldVisitor).genAnnotations(propertyDescriptor, state.getTypeMapper()); } } @@ -179,7 +175,7 @@ public class PropertyCodegen { if (kind != OwnerKind.NAMESPACE) { iv.load(0, JetTypeMapper.TYPE_OBJECT); } - final Type type = state.getTypeMapper().mapType(propertyDescriptor.getOutType()); + final Type type = state.getTypeMapper().mapType(propertyDescriptor.getType()); if (kind instanceof OwnerKind.DelegateKind) { OwnerKind.DelegateKind dk = (OwnerKind.DelegateKind) kind; dk.getDelegate().put(JetTypeMapper.TYPE_OBJECT, iv); @@ -240,7 +236,7 @@ public class PropertyCodegen { if (v.generateCode() && (!isTrait || kind instanceof OwnerKind.DelegateKind)) { mv.visitCode(); InstructionAdapter iv = new InstructionAdapter(mv); - final Type type = state.getTypeMapper().mapType(propertyDescriptor.getOutType()); + final Type type = state.getTypeMapper().mapType(propertyDescriptor.getType()); int paramCode = 0; if (kind != OwnerKind.NAMESPACE) { iv.load(0, JetTypeMapper.TYPE_OBJECT); diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/StackValue.java b/compiler/backend/src/org/jetbrains/jet/codegen/StackValue.java index 57cf22f74ad..cdd14209aab 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/StackValue.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/StackValue.java @@ -593,7 +593,7 @@ public abstract class StackValue { List valueParameters = resolvedGetCall.getResultingDescriptor().getValueParameters(); int firstParamIndex = -1; for(int i = valueParameters.size()-1; i >= 0; --i) { - Type type = codegen.typeMapper.mapType(valueParameters.get(i).getOutType()); + Type type = codegen.typeMapper.mapType(valueParameters.get(i).getType()); int sz = type.getSize(); frame.enterTemp(sz); lastIndex += sz; @@ -673,7 +673,7 @@ public abstract class StackValue { int index = firstParamIndex; for(int i = 0; i != valueParameters.size(); ++i) { - Type type = codegen.typeMapper.mapType(valueParameters.get(i).getOutType()); + Type type = codegen.typeMapper.mapType(valueParameters.get(i).getType()); int sz = type.getSize(); v.load(index-sz, type); index -= sz; @@ -701,7 +701,7 @@ public abstract class StackValue { index = firstParamIndex; for(int i = 0; i != valueParameters.size(); ++i) { - Type type = codegen.typeMapper.mapType(valueParameters.get(i).getOutType()); + Type type = codegen.typeMapper.mapType(valueParameters.get(i).getType()); int sz = type.getSize(); v.load(index-sz, type); index -= sz; @@ -725,7 +725,7 @@ public abstract class StackValue { return false; for (ValueParameterDescriptor valueParameter : valueParameters) { - if (codegen.typeMapper.mapType(valueParameter.getOutType()).getSize() != 1) + if (codegen.typeMapper.mapType(valueParameter.getType()).getSize() != 1) return false; } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethods.java b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethods.java index 975a740b687..532862d60a3 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethods.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethods.java @@ -182,8 +182,8 @@ public class IntrinsicMethods { } ); for (DeclarationDescriptor stringMember : stringMembers) { - if (stringMember instanceof NamedFunctionDescriptor) { - final NamedFunctionDescriptor stringMethod = (NamedFunctionDescriptor) stringMember; + if (stringMember instanceof SimpleFunctionDescriptor) { + final SimpleFunctionDescriptor stringMethod = (SimpleFunctionDescriptor) stringMember; final PsiMethod[] methods = stringPsiClass != null? stringPsiClass.findMethodsByName(stringMember.getName(), false) : new PsiMethod[]{}; for (PsiMethod method : methods) { diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/PsiMethodCall.java b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/PsiMethodCall.java index c8767d045ee..d95e3330174 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/PsiMethodCall.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/PsiMethodCall.java @@ -21,7 +21,7 @@ import org.jetbrains.jet.codegen.CallableMethod; import org.jetbrains.jet.codegen.ExpressionCodegen; import org.jetbrains.jet.codegen.OwnerKind; import org.jetbrains.jet.codegen.StackValue; -import org.jetbrains.jet.lang.descriptors.NamedFunctionDescriptor; +import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor; import org.jetbrains.jet.lang.psi.JetCallExpression; import org.jetbrains.jet.lang.psi.JetExpression; import org.objectweb.asm.Type; @@ -34,9 +34,9 @@ import java.util.List; * @author alex.tkachman */ public class PsiMethodCall implements IntrinsicMethod { - private final NamedFunctionDescriptor myMethod; + private final SimpleFunctionDescriptor myMethod; - public PsiMethodCall(NamedFunctionDescriptor method) { + public PsiMethodCall(SimpleFunctionDescriptor method) { myMethod = method; } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java index e4558848197..9b4d2525611 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java @@ -1240,7 +1240,7 @@ public class JavaDescriptorResolver { getterDescriptor.initialize(propertyType); } if (setterDescriptor != null) { - setterDescriptor.initialize(new ValueParameterDescriptorImpl(setterDescriptor, 0, Collections.emptyList(), "p0"/*TODO*/, false, propertyDescriptor.getOutType(), false, null)); + setterDescriptor.initialize(new ValueParameterDescriptorImpl(setterDescriptor, 0, Collections.emptyList(), "p0"/*TODO*/, false, propertyDescriptor.getType(), false, null)); } semanticServices.getTrace().record(BindingContext.VARIABLE, anyMember.getMember().psiMember, propertyDescriptor); @@ -1258,19 +1258,19 @@ public class JavaDescriptorResolver { final Set functions = new HashSet(); - Set functionsFromCurrent = Sets.newHashSet(); + Set functionsFromCurrent = Sets.newHashSet(); for (PsiMethodWrapper method : namedMembers.methods) { FunctionDescriptorImpl function = resolveMethodToFunctionDescriptor(owner, psiClass, method); if (function != null) { - functionsFromCurrent.add((NamedFunctionDescriptor) function); + functionsFromCurrent.add((SimpleFunctionDescriptor) function); } } if (owner instanceof ClassDescriptor) { ClassDescriptor classDescriptor = (ClassDescriptor) owner; - Set functionsFromSupertypes = getFunctionsFromSupertypes(scopeData, methodName); + Set functionsFromSupertypes = getFunctionsFromSupertypes(scopeData, methodName); OverrideResolver.generateOverridesInFunctionGroup(methodName, functionsFromSupertypes, functionsFromCurrent, classDescriptor, new OverrideResolver.DescriptorSink() { @Override @@ -1291,11 +1291,11 @@ public class JavaDescriptorResolver { namedMembers.functionDescriptors = functions; } - private Set getFunctionsFromSupertypes(ResolverScopeData scopeData, String methodName) { - Set r = new HashSet(); + private Set getFunctionsFromSupertypes(ResolverScopeData scopeData, String methodName) { + Set r = new HashSet(); for (JetType supertype : getSupertypes(scopeData)) { for (FunctionDescriptor function : supertype.getMemberScope().getFunctions(methodName)) { - r.add((NamedFunctionDescriptor) function); + r.add((SimpleFunctionDescriptor) function); } } return r; @@ -1429,7 +1429,7 @@ public class JavaDescriptorResolver { return null; } - NamedFunctionDescriptorImpl functionDescriptorImpl = new NamedFunctionDescriptorImpl( + SimpleFunctionDescriptorImpl functionDescriptorImpl = new SimpleFunctionDescriptorImpl( owner, resolveAnnotations(method.getPsiMethod()), method.getName(), diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorUtil.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorUtil.java index 20173f4d01a..73a48d83aa9 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorUtil.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorUtil.java @@ -68,7 +68,7 @@ public class FunctionDescriptorUtil { for (int i = 0, unsubstitutedValueParametersSize = unsubstitutedValueParameters.size(); i < unsubstitutedValueParametersSize; i++) { ValueParameterDescriptor unsubstitutedValueParameter = unsubstitutedValueParameters.get(i); // TODO : Lazy? - JetType substitutedType = substitutor.substitute(unsubstitutedValueParameter.getOutType(), Variance.IN_VARIANCE); + JetType substitutedType = substitutor.substitute(unsubstitutedValueParameter.getType(), Variance.IN_VARIANCE); JetType varargElementType = unsubstitutedValueParameter.getVarargElementType(); JetType substituteVarargElementType = varargElementType == null ? null : substitutor.substitute(varargElementType, Variance.IN_VARIANCE); if (substitutedType == null) return null; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/MutableClassDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/MutableClassDescriptor.java index cdf4dcd5aa7..be071a1d223 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/MutableClassDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/MutableClassDescriptor.java @@ -22,7 +22,6 @@ import org.jetbrains.jet.lang.psi.JetParameter; import org.jetbrains.jet.lang.resolve.AbstractScopeAdapter; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingTrace; -import org.jetbrains.jet.lang.resolve.TraceBasedRedeclarationHandler; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; @@ -39,7 +38,7 @@ import java.util.Set; public class MutableClassDescriptor extends MutableClassDescriptorLite { private final Set callableMembers = Sets.newHashSet(); private final Set properties = Sets.newHashSet(); - private final Set functions = Sets.newHashSet(); + private final Set functions = Sets.newHashSet(); private final WritableScope scopeForMemberResolution; // This scope contains type parameters but does not contain inner classes @@ -119,7 +118,7 @@ public class MutableClassDescriptor extends MutableClassDescriptorLite { } @Override - public void addFunctionDescriptor(@NotNull NamedFunctionDescriptor functionDescriptor) { + public void addFunctionDescriptor(@NotNull SimpleFunctionDescriptor functionDescriptor) { super.addFunctionDescriptor(functionDescriptor); functions.add(functionDescriptor); callableMembers.add(functionDescriptor); @@ -127,7 +126,7 @@ public class MutableClassDescriptor extends MutableClassDescriptorLite { } @NotNull - public Set getFunctions() { + public Set getFunctions() { return functions; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/MutableClassDescriptorLite.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/MutableClassDescriptorLite.java index 1b1c21fa51b..a1c2630546d 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/MutableClassDescriptorLite.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/MutableClassDescriptorLite.java @@ -252,7 +252,7 @@ public class MutableClassDescriptorLite extends MutableDeclarationDescriptor imp } @Override - public void addFunctionDescriptor(@NotNull NamedFunctionDescriptor functionDescriptor) { + public void addFunctionDescriptor(@NotNull SimpleFunctionDescriptor functionDescriptor) { getScopeForMemberLookupAsWritableScope().addFunctionDescriptor(functionDescriptor); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/NamespaceDescriptorImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/NamespaceDescriptorImpl.java index 5cf6c952a71..5b6905bfe17 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/NamespaceDescriptorImpl.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/NamespaceDescriptorImpl.java @@ -65,7 +65,7 @@ public class NamespaceDescriptorImpl extends AbstractNamespaceDescriptorImpl imp } @Override - public void addFunctionDescriptor(@NotNull NamedFunctionDescriptor functionDescriptor) { + public void addFunctionDescriptor(@NotNull SimpleFunctionDescriptor functionDescriptor) { memberScope.addFunctionDescriptor(functionDescriptor); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/NamespaceLike.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/NamespaceLike.java index b6abec0e168..4ed901a1519 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/NamespaceLike.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/NamespaceLike.java @@ -83,7 +83,7 @@ public interface NamespaceLike extends DeclarationDescriptor { void addObjectDescriptor(@NotNull MutableClassDescriptorLite objectDescriptor); - void addFunctionDescriptor(@NotNull NamedFunctionDescriptor functionDescriptor); + void addFunctionDescriptor(@NotNull SimpleFunctionDescriptor functionDescriptor); void addPropertyDescriptor(@NotNull PropertyDescriptor propertyDescriptor); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyDescriptor.java index 11bf26ae297..42a37a32945 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyDescriptor.java @@ -27,7 +27,6 @@ import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; import org.jetbrains.jet.lang.resolve.scopes.receivers.TransientReceiver; import org.jetbrains.jet.lang.types.*; -import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.Set; @@ -151,7 +150,7 @@ public class PropertyDescriptor extends VariableDescriptorImpl implements Callab @Override public JetType getReturnType() { - return getOutType(); + return getType(); } public boolean isVar() { @@ -213,7 +212,7 @@ public class PropertyDescriptor extends VariableDescriptorImpl implements Callab List substitutedTypeParameters = Lists.newArrayList(); TypeSubstitutor substitutor = DescriptorSubstitutor.substituteTypeParameters(getTypeParameters(), originalSubstitutor, substitutedDescriptor, substitutedTypeParameters); - JetType originalOutType = getOutType(); + JetType originalOutType = getType(); JetType outType = substitutor.substitute(originalOutType, Variance.OUT_VARIANCE); if (outType == null) { return null; // TODO : tell the user that the property was projected out diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyGetterDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyGetterDescriptor.java index 9be066c077e..5e6ca38b106 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyGetterDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyGetterDescriptor.java @@ -37,7 +37,7 @@ public class PropertyGetterDescriptor extends PropertyAccessorDescriptor { } public void initialize(JetType returnType) { - this.returnType = returnType == null ? getCorrespondingProperty().getOutType() : returnType; + this.returnType = returnType == null ? getCorrespondingProperty().getType() : returnType; } @NotNull diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/NamedFunctionDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/SimpleFunctionDescriptor.java similarity index 71% rename from compiler/frontend/src/org/jetbrains/jet/lang/descriptors/NamedFunctionDescriptor.java rename to compiler/frontend/src/org/jetbrains/jet/lang/descriptors/SimpleFunctionDescriptor.java index 08f3518f08c..05f756029e0 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/NamedFunctionDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/SimpleFunctionDescriptor.java @@ -19,17 +19,17 @@ package org.jetbrains.jet.lang.descriptors; import org.jetbrains.annotations.NotNull; /** - * ... and also a closure + * Simple functions are the ones with 'fun' keyword and function literals * * @author Stepan Koltsov */ -public interface NamedFunctionDescriptor extends FunctionDescriptor { +public interface SimpleFunctionDescriptor extends FunctionDescriptor { @NotNull @Override - NamedFunctionDescriptor copy(DeclarationDescriptor newOwner, boolean makeNonAbstract, Kind kind, boolean copyOverrides); + SimpleFunctionDescriptor copy(DeclarationDescriptor newOwner, boolean makeNonAbstract, Kind kind, boolean copyOverrides); @NotNull @Override - NamedFunctionDescriptor getOriginal(); + SimpleFunctionDescriptor getOriginal(); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/NamedFunctionDescriptorImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/SimpleFunctionDescriptorImpl.java similarity index 78% rename from compiler/frontend/src/org/jetbrains/jet/lang/descriptors/NamedFunctionDescriptorImpl.java rename to compiler/frontend/src/org/jetbrains/jet/lang/descriptors/SimpleFunctionDescriptorImpl.java index cfb0139073f..9ea0394a6a8 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/NamedFunctionDescriptorImpl.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/SimpleFunctionDescriptorImpl.java @@ -29,9 +29,9 @@ import java.util.List; /** * @author Stepan Koltsov */ -public class NamedFunctionDescriptorImpl extends FunctionDescriptorImpl implements NamedFunctionDescriptor { +public class SimpleFunctionDescriptorImpl extends FunctionDescriptorImpl implements SimpleFunctionDescriptor { - public NamedFunctionDescriptorImpl( + public SimpleFunctionDescriptorImpl( @NotNull DeclarationDescriptor containingDeclaration, @NotNull List annotations, @NotNull String name, @@ -39,9 +39,9 @@ public class NamedFunctionDescriptorImpl extends FunctionDescriptorImpl implemen super(containingDeclaration, annotations, name, kind); } - private NamedFunctionDescriptorImpl( + private SimpleFunctionDescriptorImpl( @NotNull DeclarationDescriptor containingDeclaration, - @NotNull NamedFunctionDescriptor original, + @NotNull SimpleFunctionDescriptor original, @NotNull List annotations, @NotNull String name, Kind kind) { @@ -55,14 +55,14 @@ public class NamedFunctionDescriptorImpl extends FunctionDescriptorImpl implemen @NotNull @Override - public NamedFunctionDescriptor getOriginal() { - return (NamedFunctionDescriptor) super.getOriginal(); + public SimpleFunctionDescriptor getOriginal() { + return (SimpleFunctionDescriptor) super.getOriginal(); } @Override protected FunctionDescriptorImpl createSubstitutedCopy(DeclarationDescriptor newOwner, boolean preserveOriginal, Kind kind) { if (preserveOriginal) { - return new NamedFunctionDescriptorImpl( + return new SimpleFunctionDescriptorImpl( newOwner, getOriginal(), // TODO : safeSubstitute @@ -70,7 +70,7 @@ public class NamedFunctionDescriptorImpl extends FunctionDescriptorImpl implemen getName(), kind); } else { - return new NamedFunctionDescriptorImpl( + return new SimpleFunctionDescriptorImpl( newOwner, // TODO : safeSubstitute getAnnotations(), @@ -81,7 +81,7 @@ public class NamedFunctionDescriptorImpl extends FunctionDescriptorImpl implemen @NotNull @Override - public NamedFunctionDescriptor copy(DeclarationDescriptor newOwner, boolean makeNonAbstract, Kind kind, boolean copyOverrides) { - return (NamedFunctionDescriptor) doSubstitute(TypeSubstitutor.EMPTY, newOwner, DescriptorUtils.convertModality(modality, makeNonAbstract), false, copyOverrides, kind); + public SimpleFunctionDescriptor copy(DeclarationDescriptor newOwner, boolean makeNonAbstract, Kind kind, boolean copyOverrides) { + return (SimpleFunctionDescriptor) doSubstitute(TypeSubstitutor.EMPTY, newOwner, DescriptorUtils.convertModality(modality, makeNonAbstract), false, copyOverrides, kind); } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ValueParameterDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ValueParameterDescriptor.java index 17df1f8b8e9..841b2b30265 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ValueParameterDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ValueParameterDescriptor.java @@ -37,7 +37,7 @@ public interface ValueParameterDescriptor extends VariableDescriptor, Annotated @Override @NotNull - JetType getOutType(); + JetType getType(); @Override ValueParameterDescriptor getOriginal(); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ValueParameterDescriptorImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ValueParameterDescriptorImpl.java index a8fd865b75c..da1f5aac7f5 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ValueParameterDescriptorImpl.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ValueParameterDescriptorImpl.java @@ -123,6 +123,6 @@ public class ValueParameterDescriptorImpl extends VariableDescriptorImpl impleme @NotNull @Override public ValueParameterDescriptor copy(@NotNull DeclarationDescriptor newOwner) { - return new ValueParameterDescriptorImpl(newOwner, index, Lists.newArrayList(getAnnotations()), getName(), isVar, getOutType(), hasDefaultValue, varargElementType); + return new ValueParameterDescriptorImpl(newOwner, index, Lists.newArrayList(getAnnotations()), getName(), isVar, getType(), hasDefaultValue, varargElementType); } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/VariableAsFunctionDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/VariableAsFunctionDescriptor.java index 43e95f175e1..860d23f5d68 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/VariableAsFunctionDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/VariableAsFunctionDescriptor.java @@ -27,7 +27,7 @@ import java.util.Collections; */ public class VariableAsFunctionDescriptor extends FunctionDescriptorImpl { public static VariableAsFunctionDescriptor create(@NotNull VariableDescriptor variableDescriptor) { - JetType outType = variableDescriptor.getOutType(); + JetType outType = variableDescriptor.getType(); assert outType != null; VariableAsFunctionDescriptor result = new VariableAsFunctionDescriptor(variableDescriptor); FunctionDescriptorUtil.initializeFromFunctionType(result, outType, variableDescriptor.getExpectedThisObject()); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/VariableDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/VariableDescriptor.java index 26a9e4c04e6..62eeaba5757 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/VariableDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/VariableDescriptor.java @@ -25,7 +25,7 @@ import org.jetbrains.jet.lang.types.TypeSubstitutor; */ public interface VariableDescriptor extends CallableDescriptor { @NotNull - JetType getOutType(); + JetType getType(); @Override @SuppressWarnings({"NullableProblems"}) diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/VariableDescriptorImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/VariableDescriptorImpl.java index ae90f6c8335..6b81ff40dd3 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/VariableDescriptorImpl.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/VariableDescriptorImpl.java @@ -52,7 +52,7 @@ public abstract class VariableDescriptorImpl extends DeclarationDescriptorImpl i } @Override - public JetType getOutType() { + public JetType getType() { return outType; } @@ -99,6 +99,6 @@ public abstract class VariableDescriptorImpl extends DeclarationDescriptorImpl i @Override public JetType getReturnType() { - return getOutType(); + return getType(); } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java index ba572dde6fc..fe4144bf623 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java @@ -146,11 +146,11 @@ public interface Errors { return super.on(elementToBlame, nodeToMark, s, classDescriptor, modifierListOwner).add(DiagnosticParameters.CLASS, modifierListOwner); } }; - PsiElementOnlyDiagnosticFactory1 ABSTRACT_FUNCTION_WITH_BODY = PsiElementOnlyDiagnosticFactory1.create(ERROR, "A function {0} with body cannot be abstract"); - PsiElementOnlyDiagnosticFactory1 NON_ABSTRACT_FUNCTION_WITH_NO_BODY = PsiElementOnlyDiagnosticFactory1.create(ERROR, "Method {0} without a body must be abstract"); - PsiElementOnlyDiagnosticFactory1 NON_MEMBER_ABSTRACT_FUNCTION = PsiElementOnlyDiagnosticFactory1.create(ERROR, "Function {0} is not a class or trait member and cannot be abstract"); + PsiElementOnlyDiagnosticFactory1 ABSTRACT_FUNCTION_WITH_BODY = PsiElementOnlyDiagnosticFactory1.create(ERROR, "A function {0} with body cannot be abstract"); + PsiElementOnlyDiagnosticFactory1 NON_ABSTRACT_FUNCTION_WITH_NO_BODY = PsiElementOnlyDiagnosticFactory1.create(ERROR, "Method {0} without a body must be abstract"); + PsiElementOnlyDiagnosticFactory1 NON_MEMBER_ABSTRACT_FUNCTION = PsiElementOnlyDiagnosticFactory1.create(ERROR, "Function {0} is not a class or trait member and cannot be abstract"); - PsiElementOnlyDiagnosticFactory1 NON_MEMBER_FUNCTION_NO_BODY = PsiElementOnlyDiagnosticFactory1.create(ERROR, "Function {0} must have a body"); + PsiElementOnlyDiagnosticFactory1 NON_MEMBER_FUNCTION_NO_BODY = PsiElementOnlyDiagnosticFactory1.create(ERROR, "Function {0} must have a body"); DiagnosticWithParameterFactory NON_FINAL_MEMBER_IN_FINAL_CLASS = DiagnosticWithParameterFactory.create(ERROR, "Non final member in a final class", DiagnosticParameters.CLASS); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnalyzingUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnalyzingUtils.java index 443b33d6333..81a522c3254 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnalyzingUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnalyzingUtils.java @@ -141,7 +141,7 @@ public class AnalyzingUtils { } @Override - public void addFunctionDescriptor(@NotNull NamedFunctionDescriptor functionDescriptor) { + public void addFunctionDescriptor(@NotNull SimpleFunctionDescriptor functionDescriptor) { scope.addFunctionDescriptor(functionDescriptor); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationResolver.java index 364c3b2a8f9..c0c6351fc31 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationResolver.java @@ -106,7 +106,7 @@ public class AnnotationResolver { List argumentExpressions = descriptorToArgument.getValue().getArgumentExpressions(); ValueParameterDescriptor parameterDescriptor = descriptorToArgument.getKey(); for (JetExpression argument : argumentExpressions) { - arguments.add(resolveAnnotationArgument(argument, parameterDescriptor.getOutType())); + arguments.add(resolveAnnotationArgument(argument, parameterDescriptor.getType())); } } descriptor.setValueArguments(arguments); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java index a93299c1363..ef916264cc2 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java @@ -149,7 +149,7 @@ public interface BindingContext { WritableSlice NAMESPACE = Slices.sliceBuilder().setOpposite((WritableSlice) DESCRIPTOR_TO_DECLARATION).build(); WritableSlice CLASS = Slices.sliceBuilder().setOpposite((WritableSlice) DESCRIPTOR_TO_DECLARATION).build(); WritableSlice TYPE_PARAMETER = Slices.sliceBuilder().setOpposite((WritableSlice) DESCRIPTOR_TO_DECLARATION).build(); - WritableSlice FUNCTION = Slices.sliceBuilder().setOpposite((WritableSlice) DESCRIPTOR_TO_DECLARATION).build(); + WritableSlice FUNCTION = Slices.sliceBuilder().setOpposite((WritableSlice) DESCRIPTOR_TO_DECLARATION).build(); WritableSlice CONSTRUCTOR = Slices.sliceBuilder().setOpposite((WritableSlice) DESCRIPTOR_TO_DECLARATION).build(); WritableSlice VARIABLE = Slices.sliceBuilder().setOpposite((WritableSlice) DESCRIPTOR_TO_DECLARATION).build(); WritableSlice VALUE_PARAMETER = Slices.sliceBuilder().setOpposite((WritableSlice) DESCRIPTOR_TO_DECLARATION).build(); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java index afa4498f491..f5f247abb66 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java @@ -468,12 +468,12 @@ public class BodyResolver { private void resolvePropertyInitializer(JetProperty property, PropertyDescriptor propertyDescriptor, JetExpression initializer, JetScope scope) { //JetFlowInformationProvider flowInformationProvider = context.getDescriptorResolver().computeFlowData(property, initializer); // TODO : flow JET-15 ExpressionTypingServices typeInferrer = context.getSemanticServices().getTypeInferrerServices(trace); - JetType expectedTypeForInitializer = property.getPropertyTypeRef() != null ? propertyDescriptor.getOutType() : NO_EXPECTED_TYPE; + JetType expectedTypeForInitializer = property.getPropertyTypeRef() != null ? propertyDescriptor.getType() : NO_EXPECTED_TYPE; JetType type = typeInferrer.getType(context.getDescriptorResolver().getPropertyDeclarationInnerScope(scope, propertyDescriptor, propertyDescriptor.getTypeParameters(), propertyDescriptor.getReceiverParameter()), initializer, expectedTypeForInitializer); // // JetType expectedType = propertyDescriptor.getInType(); // if (expectedType == null) { -// expectedType = propertyDescriptor.getOutType(); +// expectedType = propertyDescriptor.getType(); // } // if (type != null && expectedType != null // && !context.getSemanticServices().getTypeChecker().isSubtypeOf(type, expectedType)) { @@ -482,9 +482,9 @@ public class BodyResolver { } private void resolveFunctionBodies() { - for (Map.Entry entry : this.context.getFunctions().entrySet()) { + for (Map.Entry entry : this.context.getFunctions().entrySet()) { JetNamedFunction declaration = entry.getKey(); - NamedFunctionDescriptor descriptor = entry.getValue(); + SimpleFunctionDescriptor descriptor = entry.getValue(); computeDeferredType(descriptor.getReturnType()); @@ -528,7 +528,7 @@ public class BodyResolver { JetParameter jetParameter = valueParameters.get(i); JetExpression defaultValue = jetParameter.getDefaultValue(); if (defaultValue != null) { - typeInferrer.getType(declaringScope, defaultValue, valueParameterDescriptor.getOutType()); + typeInferrer.getType(declaringScope, defaultValue, valueParameterDescriptor.getType()); } } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ControlFlowAnalyzer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ControlFlowAnalyzer.java index 8a3d69534ac..49ea4a06f5f 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ControlFlowAnalyzer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ControlFlowAnalyzer.java @@ -19,7 +19,7 @@ package org.jetbrains.jet.lang.resolve; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.cfg.JetFlowInformationProvider; import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory; -import org.jetbrains.jet.lang.descriptors.NamedFunctionDescriptor; +import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor; import org.jetbrains.jet.lang.descriptors.PropertyAccessorDescriptor; import org.jetbrains.jet.lang.descriptors.PropertyDescriptor; import org.jetbrains.jet.lang.psi.*; @@ -51,9 +51,9 @@ public class ControlFlowAnalyzer { if (!context.completeAnalysisNeeded(objectDeclaration)) continue; checkClassOrObject(objectDeclaration); } - for (Map.Entry entry : context.getFunctions().entrySet()) { + for (Map.Entry entry : context.getFunctions().entrySet()) { JetNamedFunction function = entry.getKey(); - NamedFunctionDescriptor functionDescriptor = entry.getValue(); + SimpleFunctionDescriptor functionDescriptor = entry.getValue(); if (!context.completeAnalysisNeeded(function)) continue; final JetType expectedReturnType = !function.hasBlockBody() && !function.hasDeclaredReturnType() ? NO_EXPECTED_TYPE diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationResolver.java index fe83ec78a73..b67fb28557f 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationResolver.java @@ -120,7 +120,7 @@ public class DeclarationResolver { declaration.accept(new JetVisitorVoid() { @Override public void visitNamedFunction(JetNamedFunction function) { - NamedFunctionDescriptor functionDescriptor = context.getDescriptorResolver().resolveFunctionDescriptor(namespaceLike, scopeForFunctions, function); + SimpleFunctionDescriptor functionDescriptor = context.getDescriptorResolver().resolveFunctionDescriptor(namespaceLike, scopeForFunctions, function); namespaceLike.addFunctionDescriptor(functionDescriptor); context.getFunctions().put(function, functionDescriptor); context.getDeclaringScopes().put(function, scopeForFunctions); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationsChecker.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationsChecker.java index c9d21983e2d..de8956152f8 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationsChecker.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationsChecker.java @@ -71,10 +71,10 @@ public class DeclarationsChecker { checkObject(objectDeclaration, objectDescriptor); } - Map functions = context.getFunctions(); - for (Map.Entry entry : functions.entrySet()) { + Map functions = context.getFunctions(); + for (Map.Entry entry : functions.entrySet()) { JetNamedFunction function = entry.getKey(); - NamedFunctionDescriptor functionDescriptor = entry.getValue(); + SimpleFunctionDescriptor functionDescriptor = entry.getValue(); if (!context.completeAnalysisNeeded(function)) continue; checkFunction(function, functionDescriptor); @@ -246,7 +246,7 @@ public class DeclarationsChecker { } } - protected void checkFunction(JetNamedFunction function, NamedFunctionDescriptor functionDescriptor) { + protected void checkFunction(JetNamedFunction function, SimpleFunctionDescriptor functionDescriptor) { DeclarationDescriptor containingDescriptor = functionDescriptor.getContainingDeclaration(); PsiElement nameIdentifier = function.getNameIdentifier(); JetModifierList modifierList = function.getModifierList(); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegationResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegationResolver.java index 5bc14c339b5..3c54d679757 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegationResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegationResolver.java @@ -62,10 +62,10 @@ public class DelegationResolver { context.getTrace().record(DELEGATED, copy); } } - else if (declarationDescriptor instanceof NamedFunctionDescriptor) { - NamedFunctionDescriptor functionDescriptor = (NamedFunctionDescriptor) declarationDescriptor; + else if (declarationDescriptor instanceof SimpleFunctionDescriptor) { + SimpleFunctionDescriptor functionDescriptor = (SimpleFunctionDescriptor) declarationDescriptor; if (functionDescriptor.getModality().isOverridable()) { - NamedFunctionDescriptor copy = functionDescriptor.copy(classDescriptor, true, CallableMemberDescriptor.Kind.DELEGATION, true); + SimpleFunctionDescriptor copy = functionDescriptor.copy(classDescriptor, true, CallableMemberDescriptor.Kind.DELEGATION, true); classDescriptor.addFunctionDescriptor(copy); context.getTrace().record(DELEGATED, copy); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java index da45d15ff67..00afd4b0093 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java @@ -154,8 +154,8 @@ public class DescriptorResolver { } @NotNull - public NamedFunctionDescriptor resolveFunctionDescriptor(DeclarationDescriptor containingDescriptor, final JetScope scope, final JetNamedFunction function) { - final NamedFunctionDescriptorImpl functionDescriptor = new NamedFunctionDescriptorImpl( + public SimpleFunctionDescriptor resolveFunctionDescriptor(DeclarationDescriptor containingDescriptor, final JetScope scope, final JetNamedFunction function) { + final SimpleFunctionDescriptorImpl functionDescriptor = new SimpleFunctionDescriptorImpl( containingDescriptor, annotationResolver.resolveAnnotations(scope, function.getModifierList()), JetPsiUtil.safeName(function.getName()), @@ -708,11 +708,11 @@ public class DescriptorResolver { JetType type; JetTypeReference typeReference = parameter.getTypeReference(); if (typeReference == null) { - type = propertyDescriptor.getOutType(); // TODO : this maybe unknown at this point + type = propertyDescriptor.getType(); // TODO : this maybe unknown at this point } else { type = typeResolver.resolveType(scope, typeReference); - JetType inType = propertyDescriptor.getOutType(); + JetType inType = propertyDescriptor.getType(); if (inType != null) { if (!TypeUtils.equalTypes(type, inType)) { trace.report(WRONG_SETTER_PARAMETER_TYPE.on(setter, typeReference, inType)); @@ -762,7 +762,7 @@ public class DescriptorResolver { if (getter != null) { List annotations = annotationResolver.resolveAnnotations(scope, getter.getModifierList()); - JetType outType = propertyDescriptor.getOutType(); + JetType outType = propertyDescriptor.getType(); JetType returnType = outType; JetTypeReference returnTypeReference = getter.getReturnTypeReference(); if (returnTypeReference != null) { @@ -782,7 +782,7 @@ public class DescriptorResolver { } else { getterDescriptor = createDefaultGetter(propertyDescriptor); - getterDescriptor.initialize(propertyDescriptor.getOutType()); + getterDescriptor.initialize(propertyDescriptor.getType()); } return getterDescriptor; } @@ -872,7 +872,7 @@ public class DescriptorResolver { PropertySetterDescriptor setter = createDefaultSetter(propertyDescriptor); propertyDescriptor.initialize(getter, setter); - getter.initialize(propertyDescriptor.getOutType()); + getter.initialize(propertyDescriptor.getType()); trace.record(BindingContext.PRIMARY_CONSTRUCTOR_PARAMETER, parameter, propertyDescriptor); return propertyDescriptor; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java index be74a7e0f08..4dd3ee18668 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java @@ -187,7 +187,7 @@ public class DescriptorUtils { return descriptor.getName(); } - public static boolean isTopLevelFunction(@NotNull NamedFunctionDescriptor functionDescriptor) { + public static boolean isTopLevelFunction(@NotNull SimpleFunctionDescriptor functionDescriptor) { return functionDescriptor.getContainingDeclaration() instanceof NamespaceDescriptor; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/Importer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/Importer.java index 568cb7366e5..3e2eb83c7b1 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/Importer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/Importer.java @@ -83,7 +83,7 @@ public interface Importer { return; } if (descriptor instanceof VariableDescriptor) { - JetType type = ((VariableDescriptor) descriptor).getOutType(); + JetType type = ((VariableDescriptor) descriptor).getType(); namespaceScope.importScope(type.getMemberScope()); } else if (descriptor instanceof ClassDescriptor) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverloadResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverloadResolver.java index d56e1b834be..56b8a89c038 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverloadResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverloadResolver.java @@ -105,7 +105,7 @@ public class OverloadResolver { MultiMap functionsByName = MultiMap.create(); - for (NamedFunctionDescriptor function : context.getFunctions().values()) { + for (SimpleFunctionDescriptor function : context.getFunctions().values()) { DeclarationDescriptor containingDeclaration = function.getContainingDeclaration(); if (containingDeclaration instanceof NamespaceDescriptor) { NamespaceDescriptor namespaceDescriptor = (NamespaceDescriptor) containingDeclaration; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverloadUtil.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverloadUtil.java index 83151bc248b..62ae9a09de1 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverloadUtil.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverloadUtil.java @@ -18,7 +18,7 @@ package org.jetbrains.jet.lang.resolve; import org.jetbrains.jet.lang.descriptors.CallableDescriptor; import org.jetbrains.jet.lang.descriptors.ConstructorDescriptor; -import org.jetbrains.jet.lang.descriptors.NamedFunctionDescriptor; +import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor; import org.jetbrains.jet.lang.descriptors.PropertyDescriptor; /** @@ -52,7 +52,7 @@ public class OverloadUtil { private static int braceCount(CallableDescriptor a) { if (a instanceof PropertyDescriptor) { return 0; - } else if (a instanceof NamedFunctionDescriptor) { + } else if (a instanceof SimpleFunctionDescriptor) { return 1; } else if (a instanceof ConstructorDescriptor) { return 1; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java index 0a1cdf4ce6b..21e63ace72a 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverrideResolver.java @@ -106,8 +106,8 @@ public class OverrideResolver { public void addToScope(@NotNull CallableMemberDescriptor fakeOverride) { if (fakeOverride instanceof PropertyDescriptor) { classDescriptor.getScopeForMemberLookupAsWritableScope().addPropertyDescriptor((PropertyDescriptor) fakeOverride); - } else if (fakeOverride instanceof NamedFunctionDescriptor) { - classDescriptor.getScopeForMemberLookupAsWritableScope().addFunctionDescriptor((NamedFunctionDescriptor) fakeOverride); + } else if (fakeOverride instanceof SimpleFunctionDescriptor) { + classDescriptor.getScopeForMemberLookupAsWritableScope().addFunctionDescriptor((SimpleFunctionDescriptor) fakeOverride); } else { throw new IllegalStateException(fakeOverride.getClass().getName()); } @@ -191,7 +191,7 @@ public class OverrideResolver { JetScope scope) { List r = Lists.newArrayList(); for (DeclarationDescriptor decl : scope.getAllDescriptors()) { - if (decl instanceof PropertyDescriptor || decl instanceof NamedFunctionDescriptor) { + if (decl instanceof PropertyDescriptor || decl instanceof SimpleFunctionDescriptor) { r.add((CallableMemberDescriptor) decl); } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverridingUtil.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverridingUtil.java index 3e2b9262e03..74d76e33c3a 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverridingUtil.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverridingUtil.java @@ -115,7 +115,7 @@ public class OverridingUtil { parameters.add(receiverParameter.getType()); } for (ValueParameterDescriptor valueParameterDescriptor : callableDescriptor.getValueParameters()) { - parameters.add(valueParameterDescriptor.getOutType()); + parameters.add(valueParameterDescriptor.getType()); } return parameters; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java index 17feb1275e3..e8458a8bb6b 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java @@ -50,7 +50,7 @@ import java.util.Set; protected final Map namespaceDescriptors = Maps.newHashMap(); private final Map declaringScopes = Maps.newHashMap(); - private final Map functions = Maps.newLinkedHashMap(); + private final Map functions = Maps.newLinkedHashMap(); private final Map constructors = Maps.newLinkedHashMap(); private final Map properties = Maps.newLinkedHashMap(); private final Set primaryConstructorParameterProperties = Sets.newHashSet(); @@ -154,7 +154,7 @@ import java.util.Set; return declaringScopes; } - public Map getFunctions() { + public Map getFunctions() { return functions; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java index 997b37712d7..54b1f015220 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java @@ -156,7 +156,7 @@ public class TopDownAnalyzer { } @Override - public void addFunctionDescriptor(@NotNull NamedFunctionDescriptor functionDescriptor) { + public void addFunctionDescriptor(@NotNull SimpleFunctionDescriptor functionDescriptor) { throw new UnsupportedOperationException(); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java index 5fcdfeceb96..5f193da9c73 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java @@ -540,7 +540,7 @@ public class CallResolver { // We'll type check the arguments later, with the inferred types expected TemporaryBindingTrace traceForUnknown = TemporaryBindingTrace.create(temporaryTrace); ExpressionTypingServices temporaryServices = new ExpressionTypingServices(semanticServices, traceForUnknown); - JetType type = temporaryServices.getType(scope, expression, substituteDontCare.substitute(valueParameterDescriptor.getOutType(), Variance.INVARIANT)); + JetType type = temporaryServices.getType(scope, expression, substituteDontCare.substitute(valueParameterDescriptor.getType(), Variance.INVARIANT)); if (type != null && !ErrorUtils.isErrorType(type)) { constraintSystem.addSubtypingConstraint(VALUE_ARGUMENT.assertSubtyping(type, effectiveExpectedType)); } @@ -663,7 +663,7 @@ public class CallResolver { private JetType getEffectiveExpectedType(ValueParameterDescriptor valueParameterDescriptor) { JetType effectiveExpectedType = valueParameterDescriptor.getVarargElementType(); if (effectiveExpectedType == null) { - effectiveExpectedType = valueParameterDescriptor.getOutType(); + effectiveExpectedType = valueParameterDescriptor.getType(); } return effectiveExpectedType; } @@ -1002,7 +1002,7 @@ public class CallResolver { for (int i = 0; i < valueParameters.size(); i++) { ValueParameterDescriptor valueParameter = valueParameters.get(i); JetType expectedType = parameterTypes.get(i); - if (!TypeUtils.equalTypes(expectedType, valueParameter.getOutType())) return false; + if (!TypeUtils.equalTypes(expectedType, valueParameter.getType())) return false; } return true; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadingConflictResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadingConflictResolver.java index 7754aa2400d..702b82acd6a 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadingConflictResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/OverloadingConflictResolver.java @@ -22,8 +22,6 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.JetSemanticServices; import org.jetbrains.jet.lang.descriptors.CallableDescriptor; -import org.jetbrains.jet.lang.descriptors.ClassDescriptor; -import org.jetbrains.jet.lang.descriptors.ClassKind; import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.OverridingUtil; @@ -104,8 +102,8 @@ public class OverloadingConflictResolver { int fSize = fParams.size(); if (fSize != gParams.size()) return false; for (int i = 0; i < fSize; i++) { - JetType fParamType = fParams.get(i).getOutType(); - JetType gParamType = gParams.get(i).getOutType(); + JetType fParamType = fParams.get(i).getType(); + JetType gParamType = gParams.get(i).getType(); if (!typeMoreSpecific(fParamType, gParamType)) { return false; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TaskPrioritizers.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TaskPrioritizers.java index 756ab507eaa..0c58a8ce043 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TaskPrioritizers.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TaskPrioritizers.java @@ -93,7 +93,7 @@ public class TaskPrioritizers { variable = DescriptorUtils.filterNonExtensionProperty(scope.getProperties(name)); } if (variable != null) { - JetType outType = variable.getOutType(); + JetType outType = variable.getType(); if (outType != null && JetStandardClasses.isFunctionType(outType)) { VariableAsFunctionDescriptor functionDescriptor = VariableAsFunctionDescriptor.create(variable); if ((functionDescriptor.getReceiverParameter().exists()) == receiverNeeded) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowInfo.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowInfo.java index b0cfbb2051e..1633eac6468 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowInfo.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowInfo.java @@ -234,8 +234,8 @@ public class DataFlowInfo { // } // // @Nullable -// public JetType getOutType(@NotNull VariableDescriptor variableDescriptor) { -// JetType outType = variableDescriptor.getOutType(); +// public JetType getType(@NotNull VariableDescriptor variableDescriptor) { +// JetType outType = variableDescriptor.getType(); // if (outType == null) return null; // if (!outType.isNullable()) return outType; // NullabilityFlags nullabilityFlags = nullabilityInfo.get(variableDescriptor); @@ -269,7 +269,7 @@ public class DataFlowInfo { // // @NotNull // public List getPossibleTypesForVariable(@NotNull VariableDescriptor variableDescriptor) { -// return getPossibleTypes(variableDescriptor, variableDescriptor.getOutType()); +// return getPossibleTypes(variableDescriptor, variableDescriptor.getType()); // } // // public List getPossibleTypesForReceiver(@NotNull ReceiverDescriptor receiver) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowValueFactory.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowValueFactory.java index d25a9d9b0f2..c3a52353928 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowValueFactory.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowValueFactory.java @@ -57,7 +57,7 @@ public class DataFlowValueFactory { @NotNull public DataFlowValue createDataFlowValue(@NotNull VariableDescriptor variableDescriptor) { - JetType type = variableDescriptor.getOutType(); + JetType type = variableDescriptor.getType(); return new DataFlowValue(variableDescriptor, type, isStableVariable(variableDescriptor), getImmanentNullability(type)); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/ErrorUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/ErrorUtils.java index 1f8ee404562..87dcea25089 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/ErrorUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/ErrorUtils.java @@ -22,7 +22,7 @@ import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; -import org.jetbrains.jet.lang.types.error.ErrorNamedFunctionDescriptorImpl; +import org.jetbrains.jet.lang.types.error.ErrorSimpleFunctionDescriptorImpl; import java.util.*; @@ -162,8 +162,8 @@ public class ErrorUtils { CallableMemberDescriptor.Kind.DECLARATION); private static final Set ERROR_PROPERTY_GROUP = Collections.singleton(ERROR_PROPERTY); - private static NamedFunctionDescriptor createErrorFunction(ErrorScope ownerScope) { - ErrorNamedFunctionDescriptorImpl function = new ErrorNamedFunctionDescriptorImpl(ownerScope); + private static SimpleFunctionDescriptor createErrorFunction(ErrorScope ownerScope) { + ErrorSimpleFunctionDescriptorImpl function = new ErrorSimpleFunctionDescriptorImpl(ownerScope); function.initialize( null, ReceiverDescriptor.NO_RECEIVER, diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/JetStandardClasses.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/JetStandardClasses.java index f1f4c560e0c..d763b3e5ed6 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/JetStandardClasses.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/JetStandardClasses.java @@ -367,7 +367,7 @@ public class JetStandardClasses { private static List toTypes(List labeledEntries) { List result = new ArrayList(); for (ValueParameterDescriptor entry : labeledEntries) { - result.add(entry.getOutType()); + result.add(entry.getType()); } return result; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/error/ErrorNamedFunctionDescriptorImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/error/ErrorSimpleFunctionDescriptorImpl.java similarity index 70% rename from compiler/frontend/src/org/jetbrains/jet/lang/types/error/ErrorNamedFunctionDescriptorImpl.java rename to compiler/frontend/src/org/jetbrains/jet/lang/types/error/ErrorSimpleFunctionDescriptorImpl.java index 1bd033fe6f0..a5f187637b4 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/error/ErrorNamedFunctionDescriptorImpl.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/error/ErrorSimpleFunctionDescriptorImpl.java @@ -17,11 +17,8 @@ package org.jetbrains.jet.lang.types.error; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor; -import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; -import org.jetbrains.jet.lang.descriptors.FunctionDescriptorImpl; -import org.jetbrains.jet.lang.descriptors.NamedFunctionDescriptor; -import org.jetbrains.jet.lang.descriptors.NamedFunctionDescriptorImpl; +import org.jetbrains.jet.lang.descriptors.*; +import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.types.ErrorUtils; @@ -30,12 +27,12 @@ import java.util.Collections; /** * @author Stepan Koltsov */ -public class ErrorNamedFunctionDescriptorImpl extends NamedFunctionDescriptorImpl { +public class ErrorSimpleFunctionDescriptorImpl extends SimpleFunctionDescriptorImpl { // used for diagnostic only @NotNull private final ErrorUtils.ErrorScope ownerScope; - public ErrorNamedFunctionDescriptorImpl(ErrorUtils.ErrorScope ownerScope) { + public ErrorSimpleFunctionDescriptorImpl(ErrorUtils.ErrorScope ownerScope) { super(ErrorUtils.getErrorClass(), Collections.emptyList(), "", Kind.DECLARATION); this.ownerScope = ownerScope; } @@ -47,7 +44,7 @@ public class ErrorNamedFunctionDescriptorImpl extends NamedFunctionDescriptorImp @NotNull @Override - public NamedFunctionDescriptor copy(DeclarationDescriptor newOwner, boolean makeNonAbstract, Kind kind, boolean copyOverrides) { + public SimpleFunctionDescriptor copy(DeclarationDescriptor newOwner, boolean makeNonAbstract, Kind kind, boolean copyOverrides) { return this; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java index 504acf5417c..b3866940f95 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java @@ -607,7 +607,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { temporaryTrace.commit(); VariableDescriptor resultingDescriptor = resolutionResult.getResultingDescriptor(); checkSuper(receiver, resultingDescriptor, context.trace, selectorExpression); - return resultingDescriptor.getOutType(); + return resultingDescriptor.getType(); } if (resolutionResult.isAmbiguity() || resolutionResult.singleResult()) { temporaryTrace.commit(); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java index 8bcbf9a3077..e0d65f14dc2 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java @@ -84,12 +84,12 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor { JetType expectedType = context.expectedType; boolean functionTypeExpected = expectedType != TypeUtils.NO_EXPECTED_TYPE && JetStandardClasses.isFunctionType(expectedType); - NamedFunctionDescriptorImpl functionDescriptor = createFunctionDescriptor(expression, context, functionTypeExpected); + SimpleFunctionDescriptorImpl functionDescriptor = createFunctionDescriptor(expression, context, functionTypeExpected); List parameterTypes = Lists.newArrayList(); List valueParameters = functionDescriptor.getValueParameters(); for (ValueParameterDescriptor valueParameter : valueParameters) { - parameterTypes.add(valueParameter.getOutType()); + parameterTypes.add(valueParameter.getType()); } ReceiverDescriptor receiverParameter = functionDescriptor.getReceiverParameter(); JetType receiver = receiverParameter != NO_RECEIVER ? receiverParameter.getType() : null; @@ -124,10 +124,10 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor { return DataFlowUtils.checkType(JetStandardClasses.getFunctionType(Collections.emptyList(), receiver, parameterTypes, safeReturnType), expression, context); } - private NamedFunctionDescriptorImpl createFunctionDescriptor(JetFunctionLiteralExpression expression, ExpressionTypingContext context, boolean functionTypeExpected) { + private SimpleFunctionDescriptorImpl createFunctionDescriptor(JetFunctionLiteralExpression expression, ExpressionTypingContext context, boolean functionTypeExpected) { JetFunctionLiteral functionLiteral = expression.getFunctionLiteral(); JetTypeReference receiverTypeRef = functionLiteral.getReceiverTypeRef(); - NamedFunctionDescriptorImpl functionDescriptor = new NamedFunctionDescriptorImpl( + SimpleFunctionDescriptorImpl functionDescriptor = new SimpleFunctionDescriptorImpl( context.scope.getContainingDeclaration(), Collections.emptyList(), "", CallableMemberDescriptor.Kind.DECLARATION); List valueParameterDescriptors = createValueParameterDescriptors(context, functionLiteral, functionDescriptor, functionTypeExpected); @@ -161,7 +161,7 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor { if (functionTypeExpected && !hasDeclaredValueParameters && expectedValueParameters.size() == 1) { ValueParameterDescriptor valueParameterDescriptor = expectedValueParameters.get(0); ValueParameterDescriptor it = new ValueParameterDescriptorImpl( - functionDescriptor, 0, Collections.emptyList(), "it", false, valueParameterDescriptor.getOutType(), valueParameterDescriptor.hasDefaultValue(), valueParameterDescriptor.getVarargElementType() + functionDescriptor, 0, Collections.emptyList(), "it", false, valueParameterDescriptor.getType(), valueParameterDescriptor.hasDefaultValue(), valueParameterDescriptor.getVarargElementType() ); valueParameterDescriptors.add(it); context.trace.record(AUTO_CREATED_IT, it); @@ -177,7 +177,7 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor { } else { if (expectedValueParameters != null && i < expectedValueParameters.size()) { - type = expectedValueParameters.get(i).getOutType(); + type = expectedValueParameters.get(i).getType(); } else { context.trace.report(CANNOT_INFER_PARAMETER_TYPE.on(declaredParameter)); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingVisitor.java index 0a2caaa9918..1cd5fe7bc1f 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingVisitor.java @@ -22,7 +22,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; -import org.jetbrains.jet.lang.descriptors.NamedFunctionDescriptor; +import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor; import org.jetbrains.jet.lang.descriptors.VariableDescriptor; import org.jetbrains.jet.lang.diagnostics.Errors; import org.jetbrains.jet.lang.psi.*; @@ -248,7 +248,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { VariableDescriptor variableDescriptor; if (typeReference != null) { variableDescriptor = context.getDescriptorResolver().resolveLocalVariableDescriptor(context.scope.getContainingDeclaration(), context.scope, loopParameter); - JetType actualParameterType = variableDescriptor.getOutType(); + JetType actualParameterType = variableDescriptor.getType(); if (expectedParameterType != null && actualParameterType != null && !context.semanticServices.getTypeChecker().isSubtypeOf(expectedParameterType, actualParameterType)) { @@ -377,7 +377,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { if (hasNextProperty == null) { return null; } else { - JetType hasNextReturnType = hasNextProperty.getOutType(); + JetType hasNextReturnType = hasNextProperty.getType(); if (hasNextReturnType == null) { // TODO : accessibility context.trace.report(HAS_NEXT_MUST_BE_READABLE.on(loopRange)); @@ -401,7 +401,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { if (catchParameter != null) { VariableDescriptor variableDescriptor = context.getDescriptorResolver().resolveLocalVariableDescriptor(context.scope.getContainingDeclaration(), context.scope, catchParameter); JetType throwableType = context.semanticServices.getStandardLibrary().getThrowable().getDefaultType(); - DataFlowUtils.checkType(variableDescriptor.getOutType(), catchParameter, context.replaceExpectedType(throwableType)); + DataFlowUtils.checkType(variableDescriptor.getType(), catchParameter, context.replaceExpectedType(throwableType)); if (catchBody != null) { WritableScope catchScope = newWritableScopeImpl(context).setDebugName("Catch scope"); catchScope.addVariableDescriptor(variableDescriptor); @@ -479,7 +479,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { } } else if (element != null) { - NamedFunctionDescriptor functionDescriptor = context.trace.get(FUNCTION, element); + SimpleFunctionDescriptor functionDescriptor = context.trace.get(FUNCTION, element); if (functionDescriptor != null) { expectedType = DescriptorUtils.getFunctionExpectedReturnType(functionDescriptor, element); if (functionDescriptor != containingFunctionDescriptor) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java index 1546e41d55a..1aa9925ee81 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingUtils.java @@ -150,7 +150,7 @@ public class ExpressionTypingUtils { public static boolean isVariableIterable(@NotNull Project project, @NotNull VariableDescriptor variableDescriptor, @NotNull JetScope scope) { JetExpression expression = JetPsiFactory.createExpression(project, "fake"); - ExpressionReceiver expressionReceiver = new ExpressionReceiver(expression, variableDescriptor.getOutType()); + ExpressionReceiver expressionReceiver = new ExpressionReceiver(expression, variableDescriptor.getType()); ExpressionTypingContext context = ExpressionTypingContext.newContext( project, JetSemanticServices.createSemanticServices(project), diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorForStatements.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorForStatements.java index fd72918a133..85fb1a9a51e 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorForStatements.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorForStatements.java @@ -109,7 +109,7 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito VariableDescriptor propertyDescriptor = context.getDescriptorResolver().resolveLocalVariableDescriptor(scope.getContainingDeclaration(), scope, property, context.dataFlowInfo); JetExpression initializer = property.getInitializer(); if (property.getPropertyTypeRef() != null && initializer != null) { - JetType outType = propertyDescriptor.getOutType(); + JetType outType = propertyDescriptor.getType(); JetType initializerType = facade.getType(initializer, context.replaceExpectedType(outType).replaceScope(scope)); } @@ -126,7 +126,7 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito @Override public JetType visitNamedFunction(JetNamedFunction function, ExpressionTypingContext context) { - NamedFunctionDescriptor functionDescriptor = context.getDescriptorResolver().resolveFunctionDescriptor(scope.getContainingDeclaration(), scope, function); + SimpleFunctionDescriptor functionDescriptor = context.getDescriptorResolver().resolveFunctionDescriptor(scope.getContainingDeclaration(), scope, function); scope.addFunctionDescriptor(functionDescriptor); JetScope functionInnerScope = FunctionDescriptorUtil.getFunctionInnerScope(context.scope, functionDescriptor, context.trace); context.getServices().checkFunctionReturnType(functionInnerScope, function, functionDescriptor, context.dataFlowInfo); diff --git a/compiler/frontend/src/org/jetbrains/jet/resolve/DescriptorRenderer.java b/compiler/frontend/src/org/jetbrains/jet/resolve/DescriptorRenderer.java index 2da57b17e79..1d221df659d 100644 --- a/compiler/frontend/src/org/jetbrains/jet/resolve/DescriptorRenderer.java +++ b/compiler/frontend/src/org/jetbrains/jet/resolve/DescriptorRenderer.java @@ -152,7 +152,7 @@ public class DescriptorRenderer implements Renderer { @Override public Void visitVariableDescriptor(VariableDescriptor descriptor, StringBuilder builder) { - String typeString = renderPropertyPrefixAndComputeTypeString(builder, Collections.emptyList(), ReceiverDescriptor.NO_RECEIVER, descriptor.getOutType()); + String typeString = renderPropertyPrefixAndComputeTypeString(builder, Collections.emptyList(), ReceiverDescriptor.NO_RECEIVER, descriptor.getType()); renderName(descriptor, builder); builder.append(" : ").append(escape(typeString)); return super.visitVariableDescriptor(descriptor, builder); @@ -188,7 +188,7 @@ public class DescriptorRenderer implements Renderer { String typeString = renderPropertyPrefixAndComputeTypeString( builder, descriptor.getTypeParameters(), descriptor.getReceiverParameter(), - descriptor.getOutType()); + descriptor.getType()); renderName(descriptor, builder); builder.append(" : ").append(escape(typeString)); return null; diff --git a/compiler/testData/codegen/regressions/kt1406.kt b/compiler/testData/codegen/regressions/kt1406.kt new file mode 100644 index 00000000000..f66fdff9dff --- /dev/null +++ b/compiler/testData/codegen/regressions/kt1406.kt @@ -0,0 +1,26 @@ +package pack + +import java.util.Collection +import java.util.ArrayList +import java.util.regex.Pattern + +class C{ + public fun foo(){ + val items : Collection = java.util.Collections.singleton(Item()).sure() + val result = ArrayList() + val pattern: Pattern? = Pattern.compile("...") + items.filterTo(result) { + pattern.sure().matcher(it.name()).sure().matches() + } + } + + private fun Item.name() : String = "" +} + +class Item{ +} + +fun box() : String { + C().foo() + return "OK" +} \ No newline at end of file diff --git a/compiler/tests/org/jetbrains/jet/codegen/PropertyGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/PropertyGenTest.java index 99f22f965e3..bb61e4ff654 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/PropertyGenTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/PropertyGenTest.java @@ -199,6 +199,7 @@ public class PropertyGenTest extends CodegenTestCase { } public void testKt1170() throws Exception { + createEnvironmentWithFullJdk(); blackBoxFile("regressions/kt1170.kt"); } diff --git a/compiler/tests/org/jetbrains/jet/codegen/StdlibTest.java b/compiler/tests/org/jetbrains/jet/codegen/StdlibTest.java index bc9dc187f48..b1386f62dd5 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/StdlibTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/StdlibTest.java @@ -116,4 +116,8 @@ public class StdlibTest extends CodegenTestCase { throw t instanceof Exception ? (Exception)t : new RuntimeException(t); } } + + public void testKt1406() throws Exception { + blackBoxFile("regressions/kt1406.kt"); + } } diff --git a/compiler/tests/org/jetbrains/jet/compiler/NamespaceComparator.java b/compiler/tests/org/jetbrains/jet/compiler/NamespaceComparator.java index 168a611c1ed..00e16c9424c 100644 --- a/compiler/tests/org/jetbrains/jet/compiler/NamespaceComparator.java +++ b/compiler/tests/org/jetbrains/jet/compiler/NamespaceComparator.java @@ -16,7 +16,6 @@ package org.jetbrains.jet.compiler; -import com.google.common.io.ByteStreams; import com.google.common.io.Files; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.codegen.PropertyCodegen; @@ -34,7 +33,6 @@ import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor; import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; import org.jetbrains.jet.lang.descriptors.VariableDescriptor; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; -import org.jetbrains.jet.lang.psi.JetPsiUtil; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.java.JavaNamespaceDescriptor; import org.jetbrains.jet.lang.resolve.scopes.JetScope; @@ -282,7 +280,7 @@ class NamespaceComparator { } sb.append(prop.getName()); sb.append(": "); - new Serializer(sb).serialize(prop.getOutType()); + new Serializer(sb).serialize(prop.getType()); } public void serialize(ValueParameterDescriptor valueParameter) { @@ -297,7 +295,7 @@ class NamespaceComparator { if (valueParameter.getVarargElementType() != null) { serialize(valueParameter.getVarargElementType()); } else { - serialize(valueParameter.getOutType()); + serialize(valueParameter.getType()); } if (valueParameter.hasDefaultValue()) { sb.append(" = ?"); diff --git a/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java b/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java index 2ff051227c6..72ec2fecbac 100644 --- a/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java +++ b/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java @@ -142,7 +142,7 @@ public class JetResolveTest extends ExtensibleResolveTestCase { List unsubstitutedValueParameters = resolvedCall.getResultingDescriptor().getValueParameters(); for (int i = 0, unsubstitutedValueParametersSize = unsubstitutedValueParameters.size(); i < unsubstitutedValueParametersSize; i++) { ValueParameterDescriptor unsubstitutedValueParameter = unsubstitutedValueParameters.get(i); - if (unsubstitutedValueParameter.getOutType().equals(parameterType[i])) { + if (unsubstitutedValueParameter.getType().equals(parameterType[i])) { return resolvedCall.getResultingDescriptor(); } } diff --git a/compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java b/compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java index 9eba2b934c1..5778d68e488 100644 --- a/compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java +++ b/compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java @@ -90,7 +90,7 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture { List declarations = aClass.getDeclarations(); JetNamedFunction function = (JetNamedFunction) declarations.get(0); - NamedFunctionDescriptor functionDescriptor = descriptorResolver.resolveFunctionDescriptor(classDescriptor, scope, function); + SimpleFunctionDescriptor functionDescriptor = descriptorResolver.resolveFunctionDescriptor(classDescriptor, scope, function); assertEquals(expectedFunctionModality, functionDescriptor.getModality()); } diff --git a/idea/src/org/jetbrains/jet/plugin/annotations/JetLineMarkerProvider.java b/idea/src/org/jetbrains/jet/plugin/annotations/JetLineMarkerProvider.java index 77c742a2fb9..06de7bdf5e8 100644 --- a/idea/src/org/jetbrains/jet/plugin/annotations/JetLineMarkerProvider.java +++ b/idea/src/org/jetbrains/jet/plugin/annotations/JetLineMarkerProvider.java @@ -80,7 +80,7 @@ public class JetLineMarkerProvider implements LineMarkerProvider { if (element instanceof JetNamedFunction) { JetNamedFunction jetFunction = (JetNamedFunction) element; - final NamedFunctionDescriptor functionDescriptor = bindingContext.get(BindingContext.FUNCTION, jetFunction); + final SimpleFunctionDescriptor functionDescriptor = bindingContext.get(BindingContext.FUNCTION, jetFunction); if (functionDescriptor == null) return null; final Set overriddenFunctions = functionDescriptor.getOverriddenDescriptors(); Icon icon = isMember(functionDescriptor) ? (overriddenFunctions.isEmpty() ? PlatformIcons.METHOD_ICON : OVERRIDING_FUNCTION) : PlatformIcons.FUNCTION_ICON; @@ -198,7 +198,7 @@ public class JetLineMarkerProvider implements LineMarkerProvider { ); } - private boolean isMember(@NotNull NamedFunctionDescriptor functionDescriptor) { + private boolean isMember(@NotNull SimpleFunctionDescriptor functionDescriptor) { return functionDescriptor.getContainingDeclaration().getOriginal() instanceof ClassifierDescriptor; } diff --git a/idea/src/org/jetbrains/jet/plugin/caches/JetShortNamesCache.java b/idea/src/org/jetbrains/jet/plugin/caches/JetShortNamesCache.java index 4d2631d2352..1a1ce427549 100644 --- a/idea/src/org/jetbrains/jet/plugin/caches/JetShortNamesCache.java +++ b/idea/src/org/jetbrains/jet/plugin/caches/JetShortNamesCache.java @@ -29,7 +29,7 @@ import org.jetbrains.annotations.NonNls; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.asJava.JavaElementFinder; -import org.jetbrains.jet.lang.descriptors.NamedFunctionDescriptor; +import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; import org.jetbrains.jet.lang.psi.JetNamedFunction; import org.jetbrains.jet.lang.resolve.BindingContext; @@ -135,7 +135,7 @@ public class JetShortNamesCache extends PsiShortNamesCache { } @NotNull - public Collection getTopLevelFunctionDescriptorsByName(final @NotNull String name, + public Collection getTopLevelFunctionDescriptorsByName(final @NotNull String name, final @NotNull GlobalSearchScope scope) { // TODO: Add jet function in jar-dependencies (those functions are missing in BindingContext and stubs) @@ -144,10 +144,10 @@ public class JetShortNamesCache extends PsiShortNamesCache { final BindingContext context = getResolutionContext(scope); - final HashSet result = new HashSet(); + final HashSet result = new HashSet(); for (JetNamedFunction jetNamedFunction : jetNamedFunctions) { - final NamedFunctionDescriptor functionDescriptor = context.get(BindingContext.FUNCTION, jetNamedFunction); + final SimpleFunctionDescriptor functionDescriptor = context.get(BindingContext.FUNCTION, jetNamedFunction); if (functionDescriptor != null) { result.add(functionDescriptor); } @@ -181,17 +181,17 @@ public class JetShortNamesCache extends PsiShortNamesCache { return extensionFunctionNames; } - public Collection getAllJetExtensionFunctionsByName(@NotNull String name, @NotNull GlobalSearchScope scope) { + public Collection getAllJetExtensionFunctionsByName(@NotNull String name, @NotNull GlobalSearchScope scope) { // TODO: Add jet extension functions in jar-dependencies (those functions are missing in BindingContext and stubs) final Collection jetNamedFunctions = JetShortFunctionNameIndex.getInstance().get(name, project, scope); final BindingContext context = getResolutionContext(scope); - final HashSet result = new HashSet(); + final HashSet result = new HashSet(); for (JetNamedFunction jetNamedFunction : jetNamedFunctions) { - final NamedFunctionDescriptor functionDescriptor = context.get(BindingContext.FUNCTION, jetNamedFunction); + final SimpleFunctionDescriptor functionDescriptor = context.get(BindingContext.FUNCTION, jetNamedFunction); if (functionDescriptor != null) { if (functionDescriptor.getContainingDeclaration() instanceof NamespaceDescriptor) { if (functionDescriptor.getExpectedThisObject() != ReceiverDescriptor.NO_RECEIVER) { diff --git a/idea/src/org/jetbrains/jet/plugin/codeInsight/OverrideImplementMethodsHandler.java b/idea/src/org/jetbrains/jet/plugin/codeInsight/OverrideImplementMethodsHandler.java index b01acb8fa2e..0643538142c 100644 --- a/idea/src/org/jetbrains/jet/plugin/codeInsight/OverrideImplementMethodsHandler.java +++ b/idea/src/org/jetbrains/jet/plugin/codeInsight/OverrideImplementMethodsHandler.java @@ -73,8 +73,8 @@ public abstract class OverrideImplementMethodsHandler implements LanguageCodeIns for (DescriptorClassMember selectedElement : selectedElements) { final DeclarationDescriptor descriptor = selectedElement.getDescriptor(); JetFile containingFile = (JetFile) classOrObject.getContainingFile(); - if (descriptor instanceof NamedFunctionDescriptor) { - JetElement target = overrideFunction(project, containingFile, (NamedFunctionDescriptor) descriptor); + if (descriptor instanceof SimpleFunctionDescriptor) { + JetElement target = overrideFunction(project, containingFile, (SimpleFunctionDescriptor) descriptor); body.addBefore(target, body.getRBrace()); } else if (descriptor instanceof PropertyDescriptor) { @@ -92,9 +92,9 @@ public abstract class OverrideImplementMethodsHandler implements LanguageCodeIns else { bodyBuilder.append("val "); } - bodyBuilder.append(descriptor.getName()).append(": ").append(descriptor.getOutType()); - ImportClassHelper.addImportDirectiveIfNeeded(descriptor.getOutType(), file); - String initializer = defaultInitializer(descriptor.getOutType(), JetStandardLibrary.getInstance()); + bodyBuilder.append(descriptor.getName()).append(": ").append(descriptor.getType()); + ImportClassHelper.addImportDirectiveIfNeeded(descriptor.getType(), file); + String initializer = defaultInitializer(descriptor.getType(), JetStandardLibrary.getInstance()); if (initializer != null) { bodyBuilder.append("=").append(initializer); } @@ -104,7 +104,7 @@ public abstract class OverrideImplementMethodsHandler implements LanguageCodeIns return JetPsiFactory.createProperty(project, bodyBuilder.toString()); } - private static JetElement overrideFunction(Project project, JetFile file, NamedFunctionDescriptor descriptor) { + private static JetElement overrideFunction(Project project, JetFile file, SimpleFunctionDescriptor descriptor) { StringBuilder bodyBuilder = new StringBuilder("override fun "); bodyBuilder.append(descriptor.getName()); bodyBuilder.append("("); @@ -116,9 +116,9 @@ public abstract class OverrideImplementMethodsHandler implements LanguageCodeIns first = false; bodyBuilder.append(parameterDescriptor.getName()); bodyBuilder.append(": "); - bodyBuilder.append(parameterDescriptor.getOutType().toString()); + bodyBuilder.append(parameterDescriptor.getType().toString()); - ImportClassHelper.addImportDirectiveIfNeeded(parameterDescriptor.getOutType(), file); + ImportClassHelper.addImportDirectiveIfNeeded(parameterDescriptor.getType(), file); } bodyBuilder.append(")"); final JetType returnType = descriptor.getReturnType(); diff --git a/idea/src/org/jetbrains/jet/plugin/completion/DescriptorLookupConverter.java b/idea/src/org/jetbrains/jet/plugin/completion/DescriptorLookupConverter.java index 21926bbed22..3cf692c3825 100644 --- a/idea/src/org/jetbrains/jet/plugin/completion/DescriptorLookupConverter.java +++ b/idea/src/org/jetbrains/jet/plugin/completion/DescriptorLookupConverter.java @@ -64,7 +64,7 @@ public final class DescriptorLookupConverter { @Override public String fun(ValueParameterDescriptor valueParameterDescriptor) { return valueParameterDescriptor.getName() + ":" + - DescriptorRenderer.TEXT.renderType(valueParameterDescriptor.getOutType()); + DescriptorRenderer.TEXT.renderType(valueParameterDescriptor.getType()); } }, ",") + ")"; @@ -78,7 +78,7 @@ public final class DescriptorLookupConverter { } } else if (descriptor instanceof VariableDescriptor) { - JetType outType = ((VariableDescriptor) descriptor).getOutType(); + JetType outType = ((VariableDescriptor) descriptor).getType(); typeText = DescriptorRenderer.TEXT.renderType(outType); } else if (descriptor instanceof ClassDescriptor) { diff --git a/idea/src/org/jetbrains/jet/plugin/completion/handlers/JetFunctionInsertHandler.java b/idea/src/org/jetbrains/jet/plugin/completion/handlers/JetFunctionInsertHandler.java index 8cb1574b41c..637bbf68543 100644 --- a/idea/src/org/jetbrains/jet/plugin/completion/handlers/JetFunctionInsertHandler.java +++ b/idea/src/org/jetbrains/jet/plugin/completion/handlers/JetFunctionInsertHandler.java @@ -28,7 +28,7 @@ import com.intellij.psi.PsiElement; import com.intellij.psi.util.PsiTreeUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; -import org.jetbrains.jet.lang.descriptors.NamedFunctionDescriptor; +import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.psi.JetImportDirective; import org.jetbrains.jet.lang.psi.JetQualifiedExpression; @@ -122,10 +122,10 @@ public class JetFunctionInsertHandler implements InsertHandler { if (context.getFile() instanceof JetFile && item.getObject() instanceof JetLookupObject) { final DeclarationDescriptor descriptor = ((JetLookupObject) item.getObject()).getDescriptor(); - if (descriptor instanceof NamedFunctionDescriptor) { + if (descriptor instanceof SimpleFunctionDescriptor) { final JetFile file = (JetFile) context.getFile(); - NamedFunctionDescriptor functionDescriptor = (NamedFunctionDescriptor) descriptor; + SimpleFunctionDescriptor functionDescriptor = (SimpleFunctionDescriptor) descriptor; final String fqn = DescriptorUtils.getFQName(functionDescriptor); if (DescriptorUtils.isTopLevelFunction(functionDescriptor)) { diff --git a/idea/src/org/jetbrains/jet/plugin/parameterInfo/JetFunctionParameterInfoHandler.java b/idea/src/org/jetbrains/jet/plugin/parameterInfo/JetFunctionParameterInfoHandler.java index 1009d2be0f5..c1320422e84 100644 --- a/idea/src/org/jetbrains/jet/plugin/parameterInfo/JetFunctionParameterInfoHandler.java +++ b/idea/src/org/jetbrains/jet/plugin/parameterInfo/JetFunctionParameterInfoHandler.java @@ -173,7 +173,7 @@ public class JetFunctionParameterInfoHandler implements } private static JetType getActualParameterType(ValueParameterDescriptor descriptor) { - JetType paramType = descriptor.getOutType(); + JetType paramType = descriptor.getType(); if (descriptor.getVarargElementType() != null) paramType = descriptor.getVarargElementType(); return paramType; } diff --git a/idea/src/org/jetbrains/jet/plugin/structureView/JetStructureViewElement.java b/idea/src/org/jetbrains/jet/plugin/structureView/JetStructureViewElement.java index d2b790b6b5b..de311fa696f 100644 --- a/idea/src/org/jetbrains/jet/plugin/structureView/JetStructureViewElement.java +++ b/idea/src/org/jetbrains/jet/plugin/structureView/JetStructureViewElement.java @@ -190,7 +190,7 @@ public class JetStructureViewElement implements StructureViewTreeElement { @Override public String fun(ValueParameterDescriptor valueParameterDescriptor) { return valueParameterDescriptor.getName() + ":" + - DescriptorRenderer.TEXT.renderType(valueParameterDescriptor.getOutType()); + DescriptorRenderer.TEXT.renderType(valueParameterDescriptor.getType()); } }, ","); @@ -201,7 +201,7 @@ public class JetStructureViewElement implements StructureViewTreeElement { textBuilder.append(":").append(DescriptorRenderer.TEXT.renderType(returnType)); } else if (descriptor instanceof VariableDescriptor) { - JetType outType = ((VariableDescriptor) descriptor).getOutType(); + JetType outType = ((VariableDescriptor) descriptor).getType(); textBuilder = new StringBuilder(descriptor.getName()); textBuilder.append(":").append(DescriptorRenderer.TEXT.renderType(outType));