Fixed assertion + refactored code making it more simple

j2k/src/org/jetbrains/jet/j2k/visitors/TypeVisitor.kt

@@ -22,8 +22,6 @@ import org.jetbrains.jet.j2k.ast.*
 import com.intellij.openapi.util.text.StringUtil
 import org.jetbrains.jet.lang.resolve.java.JvmPrimitiveType
 import org.jetbrains.jet.j2k.TypeConverter
-import java.util.ArrayList
-import org.jetbrains.jet.j2k.singleOrNull2
 import org.jetbrains.jet.j2k.Converter
 
 private val PRIMITIVE_TYPES_NAMES = JvmPrimitiveType.values().map { it.getName() }
@@ -84,39 +82,25 @@ class TypeVisitor(private val converter: Converter) : PsiTypeVisitor<Type>() {
     private fun getShortName(className: String): String = className.substring(className.lastIndexOf('.') + 1)
 
     private fun convertTypeArgs(classType: PsiClassType): List<Type> {
-        val resolvedClassTypeParams = createRawTypesForResolvedReference(classType)
+        if (classType.getParameterCount() == 0) {
-
+            return createTypeArgsForRawTypeUsage(classType)
-        if (classType.getParameterCount() == 0 && resolvedClassTypeParams.size() > 0) {
-            if ((resolvedClassTypeParams.singleOrNull2() as? ClassType)?.referenceElement?.name?.name == "Any") {
-                return listOf(StarProjectionType().assignNoPrototype())
-            }
-            else {
-                return resolvedClassTypeParams
-            }
         }
         else {
             return typeConverter.convertTypes(classType.getParameters())
         }
     }
 
-    private fun createRawTypesForResolvedReference(classType: PsiClassType): List<Type> {
+    private fun createTypeArgsForRawTypeUsage(classType: PsiClassType): List<Type> {
-        val typeArgs = ArrayList<Type>()
         if (classType is PsiClassReferenceType) {
-            val resolve = classType.getReference().resolve()
+            val targetClass = classType.getReference().resolve() as? PsiClass
-            if (resolve is PsiClass) {
+            if (targetClass != null) {
-                for (typeParam in resolve.getTypeParameters()) {
+                return targetClass.getTypeParameters().map {
-                    val superTypes = typeParam.getSuperTypes()
+                    val superType = it.getSuperTypes().first() // there must be at least one super type always
-                    val boundType = if (superTypes.size > 0) {
+                    ClassType(constructReferenceElement(superType), Nullability.Default, converter.settings).assignNoPrototype()
-                        ClassType(constructReferenceElement(superTypes.first()), Nullability.Default, converter.settings)
-                    }
-                    else {
-                        StarProjectionType()
-                    }
-                    typeArgs.add(boundType)
                 }
             }
         }
-        return typeArgs
+        return listOf()
     }
 
     override fun visitWildcardType(wildcardType: PsiWildcardType): Type {

j2k/tests/test/org/jetbrains/jet/j2k/test/JavaToKotlinConverterTestGenerated.java

@@ -3138,6 +3138,11 @@ public class JavaToKotlinConverterTestGenerated extends AbstractJavaToKotlinConv
             doTest("j2k/tests/testData/ast/typeParameters/needTypeArgs.java");
         }
         
+        @TestMetadata("rawTypeCast.java")
+        public void testRawTypeCast() throws Exception {
+            doTest("j2k/tests/testData/ast/typeParameters/rawTypeCast.java");
+        }
+        
         @TestMetadata("traitDoubleParametrizationWithTwoBoundsWithExtending.java")
         public void testTraitDoubleParametrizationWithTwoBoundsWithExtending() throws Exception {
             doTest("j2k/tests/testData/ast/typeParameters/traitDoubleParametrizationWithTwoBoundsWithExtending.java");

j2k/tests/testData/ast/typeParameters/rawTypeCast.java

@@ -0,0 +1,8 @@
+import java.util.*;
+
+class A {
+    public static Map<String, String> foo() {
+        Properties props = new Properties();
+        return new HashMap<>((Map)props);
+    }
+}

j2k/tests/testData/ast/typeParameters/rawTypeCast.kt

@@ -0,0 +1,11 @@
+import java.util.*
+import kotlin.Map
+
+class A {
+    class object {
+        public fun foo(): Map<String, String> {
+            val props = Properties()
+            return HashMap(props as Map<Any, Any>)
+        }
+    }
+}