Refine generic signature for fields

- For vals use the same semantics as for return types
- For vars use the same semantics as for value parameters

compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java

@@ -886,7 +886,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
             int modifiers = ACC_STATIC | ACC_FINAL | ACC_PUBLIC | (property.isConst() ? 0 : ACC_DEPRECATED);
             FieldVisitor fv = v.newField(JvmDeclarationOriginKt.Synthetic(DescriptorToSourceUtils.descriptorToDeclaration(property), property),
                                          modifiers, context.getFieldName(property, false),
-                                         type.getDescriptor(), typeMapper.mapFieldSignature(property.getType()),
+                                         type.getDescriptor(), typeMapper.mapFieldSignature(property.getType(), property),
                                          info.defaultValue);
 
             AnnotationCodegen.forField(fv, typeMapper).genAnnotations(property, type);

compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyCodegen.java

@@ -360,7 +360,7 @@ public class PropertyCodegen {
         v.getSerializationBindings().put(FIELD_FOR_PROPERTY, propertyDescriptor, Pair.create(type, name));
 
         FieldVisitor fv = builder.newField(JvmDeclarationOriginKt.OtherOrigin(element, propertyDescriptor), modifiers, name, type.getDescriptor(),
-                                           typeMapper.mapFieldSignature(jetType), defaultValue);
+                                           typeMapper.mapFieldSignature(jetType, propertyDescriptor), defaultValue);
 
         Annotated fieldAnnotated = new AnnotatedWithFakeAnnotations(propertyDescriptor, annotations);
         AnnotationCodegen.forField(fv, typeMapper).genAnnotations(fieldAnnotated, type, AnnotationUseSiteTarget.FIELD);

compiler/backend/src/org/jetbrains/kotlin/codegen/state/JetTypeMapper.java

@@ -325,20 +325,24 @@ public class JetTypeMapper {
             //noinspection ConstantConditions
             return mapType(descriptor.getReturnType(), sw, TypeMappingMode.GENERIC_TYPE);
         }
-        else {
-            boolean isAnnotationMethod = DescriptorUtils.isAnnotationClass(descriptor.getContainingDeclaration());
-            TypeMappingMode typeMappingModeFromAnnotation =
-                    TypeMappingUtil.extractTypeMappingModeFromAnnotation(descriptor, returnType, isAnnotationMethod);
-            if (typeMappingModeFromAnnotation != null) {
-                return mapType(returnType, sw, typeMappingModeFromAnnotation);
-            }
 
-            TypeMappingMode mappingMode = TypeMappingMode.getOptimalModeForReturnType(
-                    returnType,
-                    /* isAnnotationMethod = */ isAnnotationMethod);
+        return mapReturnType(descriptor, sw, returnType);
+    }
 
-            return mapType(returnType, sw, mappingMode);
+    @NotNull
+    private Type mapReturnType(@NotNull CallableDescriptor descriptor, @Nullable BothSignatureWriter sw, @NotNull KotlinType returnType) {
+        boolean isAnnotationMethod = DescriptorUtils.isAnnotationClass(descriptor.getContainingDeclaration());
+        TypeMappingMode typeMappingModeFromAnnotation =
+                TypeMappingUtil.extractTypeMappingModeFromAnnotation(descriptor, returnType, isAnnotationMethod);
+        if (typeMappingModeFromAnnotation != null) {
+            return mapType(returnType, sw, typeMappingModeFromAnnotation);
         }
+
+        TypeMappingMode mappingMode = TypeMappingMode.getOptimalModeForReturnType(
+                returnType,
+                /* isAnnotationMethod = */ isAnnotationMethod);
+
+        return mapType(returnType, sw, mappingMode);
     }
 
     @NotNull
@@ -1108,9 +1112,16 @@ public class JetTypeMapper {
     }
 
     @Nullable
-    public String mapFieldSignature(@NotNull KotlinType backingFieldType) {
+    public String mapFieldSignature(@NotNull KotlinType backingFieldType, @NotNull PropertyDescriptor propertyDescriptor) {
         BothSignatureWriter sw = new BothSignatureWriter(BothSignatureWriter.Mode.TYPE);
-        mapType(backingFieldType, sw, TypeMappingMode.DEFAULT);
+
+        if (!propertyDescriptor.isVar()) {
+            mapReturnType(propertyDescriptor, sw, backingFieldType);
+        }
+        else {
+            writeParameterType(sw, backingFieldType, propertyDescriptor);
+        }
+
         return sw.makeJavaGenericSignature();
     }
 
@@ -1211,6 +1222,16 @@ public class JetTypeMapper {
     ) {
         sw.writeParameterType(kind);
 
+        writeParameterType(sw, type, callableDescriptor);
+
+        sw.writeParameterTypeEnd();
+    }
+
+    private void writeParameterType(
+            @NotNull BothSignatureWriter sw,
+            @NotNull KotlinType type,
+            @NotNull CallableDescriptor callableDescriptor
+    ) {
         TypeMappingMode typeMappingMode;
 
         TypeMappingMode typeMappingModeFromAnnotation =
@@ -1227,8 +1248,6 @@ public class JetTypeMapper {
         }
 
         mapType(type, sw, typeMappingMode);
-
-        sw.writeParameterTypeEnd();
     }
 
     private static void writeParameter(@NotNull BothSignatureWriter sw, @NotNull JvmMethodParameterKind kind, @NotNull Type type) {