ReadKotlinBinaryClassTest: nullability

compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java

@@ -124,6 +124,9 @@ public class FunctionCodegen {
                             av.visit(JvmStdlibNames.JET_VALUE_PARAMETER_NULLABLE_FIELD, true);
                         }
                         av.visit(JvmStdlibNames.JET_VALUE_PARAMETER_RECEIVER_FIELD, true);
+                        if (jvmSignature.getKotlinParameterTypes() != null && jvmSignature.getKotlinParameterTypes().get(0) != null) {
+                            av.visit(JvmStdlibNames.JET_VALUE_PARAMETER_TYPE_FIELD, jvmSignature.getKotlinParameterTypes().get(0).getKotlinSignature());
+                        }
                         av.visitEnd();
                     }
                     for (final TypeParameterDescriptor typeParameterDescriptor : typeParameters) {

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java

@@ -735,15 +735,6 @@ public class JavaDescriptorResolver {
 
         PsiType psiType = parameter.getPsiParameter().getType();
 
-        JetType varargElementType;
-        if (psiType instanceof PsiEllipsisType) {
-            PsiEllipsisType psiEllipsisType = (PsiEllipsisType) psiType;
-            varargElementType = semanticServices.getTypeTransformer().transformToType(psiEllipsisType.getComponentType());
-        }
-        else {
-            varargElementType = null;
-        }
-
         boolean nullable = parameter.getJetValueParameter().nullable();
 
         // TODO: must be very slow, make it lazy?
@@ -763,6 +754,14 @@ public class JavaDescriptorResolver {
         } else {
             outType = semanticServices.getTypeTransformer().transformToType(psiType);
         }
+
+        JetType varargElementType;
+        if (psiType instanceof PsiEllipsisType) {
+            varargElementType = semanticServices.getJetSemanticServices().getStandardLibrary().getArrayElementType(outType);
+        } else {
+            varargElementType = null;
+        }
+
         if (receiver) {
             return JvmMethodParameterMeaning.receiver(outType);
         } else {
@@ -823,8 +822,8 @@ public class JavaDescriptorResolver {
             return;
         }
         
-        PsiType propertyType = namedMembers.properties.type;
-        PsiType receiverType = namedMembers.properties.receiverType;
+        TypeSource propertyType = namedMembers.properties.type;
+        TypeSource receiver = namedMembers.properties.receiverType;
         MembersForProperty members = namedMembers.properties;
 
         boolean isFinal;
@@ -894,15 +893,28 @@ public class JavaDescriptorResolver {
             // call ugly code with side effects
             typeParameters = resolveMethodTypeParameters(members.getter, propertyDescriptor.getGetter(), typeVariableResolver);
         }
+        
+        List<TypeParameterDescriptor> typeParametersForReceiver = new ArrayList<TypeParameterDescriptor>();
+        typeParametersForReceiver.addAll(classTypeParameters);
+        typeParametersForReceiver.addAll(typeParameters);
 
+        TypeParameterListTypeVariableResolver typeVariableResolverForPropertyInternals = new TypeParameterListTypeVariableResolver(typeParametersForReceiver);
+        
         JetType receiverJetType;
-        if (receiverType == null) {
+        if (receiver == null) {
             receiverJetType = null;
+        } else if (receiver.getTypeString().length() > 0) {
+            receiverJetType = semanticServices.getTypeTransformer().transformToType(receiver.getTypeString(), typeVariableResolverForPropertyInternals);
         } else {
-            receiverJetType = semanticServices.getTypeTransformer().transformToType(receiverType);
+            receiverJetType = semanticServices.getTypeTransformer().transformToType(receiver.getPsiType());
         }
 
-        JetType type = semanticServices.getTypeTransformer().transformToType(propertyType);
+        JetType type;
+        if (propertyType.getTypeString().length() > 0) {
+            type = semanticServices.getTypeTransformer().transformToType(propertyType.getTypeString(), typeVariableResolverForPropertyInternals);
+        } else {
+            type = semanticServices.getTypeTransformer().transformToType(propertyType.getPsiType());
+        }
 
         propertyDescriptor.setType(
                 type,

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolverHelper.java

@@ -2,7 +2,6 @@ package org.jetbrains.jet.lang.resolve.java;
 
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.psi.HierarchicalMethodSignature;
-import com.intellij.psi.PsiType;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.HashMap;
@@ -12,8 +11,8 @@ import java.util.Map;
  * @author Stepan Koltsov
  */
 class JavaDescriptorResolverHelper {
-    
-    
+
+
     private static class Builder {
         private final PsiClassWrapper psiClass;
         private final boolean staticMembers;
@@ -57,7 +56,7 @@ class JavaDescriptorResolverHelper {
 
                     MembersForProperty members = new MembersForProperty();
                     members.field = field;
-                    members.type = field.getType();
+                    members.type = new TypeSource("", field.getType());
 
                     namedMembers.properties = members;
                 }
@@ -90,9 +89,10 @@ class JavaDescriptorResolverHelper {
 
                         int i = 0;
 
-                        PsiType receiverType;
+                        TypeSource receiverType;
                         if (i < method.getParameters().size() && method.getParameter(i).getJetValueParameter().receiver()) {
-                            receiverType = method.getParameter(i).getPsiParameter().getType();
+                            PsiParameterWrapper receiverParameter = method.getParameter(i);
+                            receiverType = new TypeSource(receiverParameter.getJetValueParameter().type(), receiverParameter.getPsiParameter().getType());
                             ++i;
                         } else {
                             receiverType = null;
@@ -114,7 +114,7 @@ class JavaDescriptorResolverHelper {
 
                         // TODO: check conflicts with setter
                         // TODO: what if returnType == null?
-                        members.getForProperty().type = method.getReturnType();
+                        members.getForProperty().type = new TypeSource(method.getJetMethod().propertyType(), method.getReturnType());
                         members.getForProperty().receiverType = receiverType;
                     }
                 } else if (method.getName().startsWith(JvmAbi.SETTER_PREFIX)) {
@@ -127,10 +127,10 @@ class JavaDescriptorResolverHelper {
 
                         int i = 0;
 
-                        PsiType receiverType = null;
+                        TypeSource receiverType = null;
                         PsiParameterWrapper p1 = method.getParameter(0);
                         if (p1.getJetValueParameter().receiver()) {
-                            receiverType = p1.getPsiParameter().getType();
+                            receiverType = new TypeSource(p1.getJetValueParameter().type(), p1.getPsiParameter().getType());
                             ++i;
                         }
 
@@ -142,7 +142,8 @@ class JavaDescriptorResolverHelper {
                             throw new IllegalStateException();
                         }
 
-                        PsiType propertyType = method.getParameter(i).getPsiParameter().getType();
+                        PsiParameterWrapper propertyTypeParameter = method.getParameter(i);
+                        TypeSource propertyType = new TypeSource(method.getJetMethod().propertyType(), propertyTypeParameter.getPsiParameter().getType());
 
                         String propertyName = StringUtil.decapitalize(method.getName().substring(JvmAbi.SETTER_PREFIX.length()));
                         NamedMembers members = getNamedMembers(propertyName);

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/MembersForProperty.java

 package org.jetbrains.jet.lang.resolve.java;
 
-import com.intellij.psi.PsiType;
-
 /**
 * @author Stepan Koltsov
 */
@@ -10,6 +8,6 @@ class MembersForProperty {
     PsiMethodWrapper setter;
     PsiMethodWrapper getter;
 
-    PsiType type;
-    PsiType receiverType;
+    TypeSource type;
+    TypeSource receiverType;
 }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/TypeSource.java

+package org.jetbrains.jet.lang.resolve.java;
+
+import com.intellij.psi.PsiType;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * @author Stepan Koltsov
+ */
+class TypeSource {
+
+    @NotNull
+    private final String typeString;
+    @NotNull
+    private final PsiType psiType;
+
+    TypeSource(@NotNull String typeString, @NotNull PsiType psiType) {
+        this.typeString = typeString;
+        this.psiType = psiType;
+    }
+
+    @NotNull
+    public String getTypeString() {
+        return typeString;
+    }
+
+    @NotNull
+    public PsiType getPsiType() {
+        return psiType;
+    }
+}

compiler/frontend/src/org/jetbrains/jet/lang/types/JetStandardLibrary.java

@@ -78,6 +78,7 @@ public class JetStandardLibrary {
     private EnumMap<PrimitiveType, JetType> primitiveTypeToArrayJetType;
     private EnumMap<PrimitiveType, JetType> primitiveTypeToNullableArrayJetType;
     private Map<JetType, JetType> primitiveJetTypeToJetArrayType;
+    private Map<JetType, JetType> jetArrayTypeToPrimitiveJetType;
 
     private JetStandardLibrary(@NotNull Project project) {
         // TODO : review
@@ -147,6 +148,7 @@ public class JetStandardLibrary {
             primitiveTypeToArrayJetType = new EnumMap<PrimitiveType, JetType>(PrimitiveType.class);
             primitiveTypeToNullableArrayJetType = new EnumMap<PrimitiveType, JetType>(PrimitiveType.class);
             primitiveJetTypeToJetArrayType = new HashMap<JetType, JetType>();
+            jetArrayTypeToPrimitiveJetType = new HashMap<JetType, JetType>();
 
             for (PrimitiveType primitive : PrimitiveType.values()) {
                 makePrimitive(primitive);
@@ -167,6 +169,7 @@ public class JetStandardLibrary {
         primitiveTypeToArrayJetType.put(primitiveType, arrayType);
         primitiveTypeToNullableArrayJetType.put(primitiveType, TypeUtils.makeNullable(arrayType));
         primitiveJetTypeToJetArrayType.put(type, arrayType);
+        jetArrayTypeToPrimitiveJetType.put(arrayType, type);
     }
 
     @NotNull
@@ -334,6 +337,22 @@ public class JetStandardLibrary {
                 getArray().getMemberScope(types)
         );
     }
+    
+    @NotNull
+    public JetType getArrayElementType(@NotNull JetType arrayType) {
+        // make non-null?
+        if (arrayType.getConstructor().getDeclarationDescriptor() == getArray()) {
+            if (arrayType.getArguments().size() != 1) {
+                throw new IllegalStateException();
+            }
+            return arrayType.getArguments().get(0).getType();
+        }
+        JetType primitiveType = jetArrayTypeToPrimitiveJetType.get(arrayType);
+        if (primitiveType == null) {
+            throw new IllegalStateException("not array: " + arrayType);
+        }
+        return primitiveType;
+    }
 
     @NotNull
     public JetType getIterableType(@NotNull JetType argument) {

compiler/tests/org/jetbrains/jet/NamespaceComparator.java

@@ -274,6 +274,9 @@ class NamespaceComparator {
                 }
                 sb.append(">");
             }
+            if (type.isNullable()) {
+                sb.append("?");
+            }
         }
 
         public void serializeCommaSeparated(List<?> list) {