DescriptorSearchRule should help detecting loops

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

+/*
+ * Copyright 2010-2012 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.jet.lang.resolve.java;
+
+/**
+ * @author Stepan Koltsov
+ */
+public enum DescriptorSearchRule {
+    INCLUDE_KOTLIN,
+    IGNORE_IF_FOUND_IN_KOTLIN,
+    ERROR_IF_FOUND_IN_KOTLIN,
+}

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

@@ -103,7 +103,7 @@ public class JavaClassMembersScope extends JavaClassOrPackageScope {
         for (PsiClass innerClass : psiClass.getAllInnerClasses()) {
             if (name.equals(innerClass.getName())) {
                 if (innerClass.hasModifierProperty(PsiModifier.STATIC) != staticMembers) return null;
-                ClassDescriptor classDescriptor = semanticServices.getDescriptorResolver().resolveClass(innerClass);
+                ClassDescriptor classDescriptor = semanticServices.getDescriptorResolver().resolveClass(innerClass, DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
                 if (classDescriptor != null) {
                     return classDescriptor;
                 }

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

@@ -211,7 +211,7 @@ public class JavaDescriptorResolver {
     }
     
     @Nullable
-    ResolverClassData resolveClassData(@NotNull PsiClass psiClass) {
+    ResolverClassData resolveClassData(@NotNull PsiClass psiClass, @NotNull DescriptorSearchRule searchRule) {
         FqName qualifiedName = new FqName(psiClass.getQualifiedName());
 
         if (qualifiedName.getFqName().endsWith(JvmAbi.TRAIT_IMPL_SUFFIX)) {
@@ -219,17 +219,30 @@ public class JavaDescriptorResolver {
             return null;
         }
 
+        ClassDescriptor builtinClassDescriptor = semanticServices.getKotlinBuiltinClassDescriptor(qualifiedName);
+        if (builtinClassDescriptor != null) {
+            return new ResolverSrcClassData(builtinClassDescriptor);
+        }
+
         // First, let's check that this is a real Java class, not a Java's view on a Kotlin class:
         ClassDescriptor kotlinClassDescriptor = semanticServices.getKotlinClassDescriptor(qualifiedName);
         if (kotlinClassDescriptor != null) {
-            // TODO: return null, no loops here
-            return new ResolverSrcClassData(kotlinClassDescriptor);
+            if (searchRule == DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN) {
+                throw new IllegalStateException("class must not be found in kotlin: " + qualifiedName);
+            } else if (searchRule == DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN) {
+                return null;
+            } else if (searchRule == DescriptorSearchRule.INCLUDE_KOTLIN) {
+                // TODO: probably this is evil
+                return new ResolverSrcClassData(kotlinClassDescriptor);
+            } else {
+                throw new IllegalStateException("unknown searchRule: " + searchRule);
+            }
         }
 
         PsiClass containingClass = psiClass.getContainingClass();
         if (containingClass != null) {
             // must resolve containing class first, because inner class must have a reference to it
-            resolveClass(containingClass);
+            resolveClass(containingClass, DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
         }
 
         // Not let's take a descriptor of a Java class
@@ -242,8 +255,8 @@ public class JavaDescriptorResolver {
     }
 
     @Nullable
-    public ClassDescriptor resolveClass(@NotNull PsiClass psiClass) {
-        ResolverClassData classData = resolveClassData(psiClass);
+    public ClassDescriptor resolveClass(@NotNull PsiClass psiClass, @NotNull DescriptorSearchRule searchRule) {
+        ResolverClassData classData = resolveClassData(psiClass, searchRule);
         if (classData != null) {
             return classData.getClassDescriptor();
         } else {
@@ -252,18 +265,30 @@ public class JavaDescriptorResolver {
     }
 
     @Nullable
-    public ClassDescriptor resolveClass(@NotNull FqName qualifiedName) {
+    public ClassDescriptor resolveClass(@NotNull FqName qualifiedName, @NotNull DescriptorSearchRule searchRule) {
 
         if (qualifiedName.getFqName().endsWith(JvmAbi.TRAIT_IMPL_SUFFIX)) {
             // TODO: only if -$$TImpl class is created by Kotlin
             return null;
         }
-        
+
+        ClassDescriptor builtinClassDescriptor = semanticServices.getKotlinBuiltinClassDescriptor(qualifiedName);
+        if (builtinClassDescriptor != null) {
+            return builtinClassDescriptor;
+        }
+
         // First, let's check that this is a real Java class, not a Java's view on a Kotlin class:
         ClassDescriptor kotlinClassDescriptor = semanticServices.getKotlinClassDescriptor(qualifiedName);
         if (kotlinClassDescriptor != null) {
-            // TODO: return null, no loops here
-            return kotlinClassDescriptor;
+            if (searchRule == DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN) {
+                throw new IllegalStateException("class must not be found in kotlin: " + qualifiedName);
+            } else if (searchRule == DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN) {
+                return null;
+            } else if (searchRule == DescriptorSearchRule.INCLUDE_KOTLIN) {
+                return kotlinClassDescriptor;
+            } else {
+                throw new IllegalStateException("unknown searchRule: " + searchRule);
+            }
         }
 
         // Not let's take a descriptor of a Java class
@@ -509,7 +534,7 @@ public class JavaDescriptorResolver {
     @NotNull
     private ClassDescriptor getJavaLangObject() {
         if (javaLangObject == null) {
-            javaLangObject = resolveClass(new FqName("java.lang.Object"));
+            javaLangObject = resolveClass(new FqName("java.lang.Object"), DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN);
         }
         return javaLangObject;
     }
@@ -653,10 +678,10 @@ public class JavaDescriptorResolver {
     private ClassOrNamespaceDescriptor resolveParentDescriptor(PsiClass psiClass) {
         PsiClass containingClass = psiClass.getContainingClass();
         if (containingClass != null) {
-            return resolveClass(containingClass);
+            return resolveClass(containingClass, DescriptorSearchRule.INCLUDE_KOTLIN);
         }
 
-        return resolveNamespace(new FqName(psiClass.getQualifiedName()).parent());
+        return resolveNamespace(new FqName(psiClass.getQualifiedName()).parent(), DescriptorSearchRule.INCLUDE_KOTLIN);
     }
 
     private List<TypeParameterDescriptorInitialization> makeUninitializedTypeParameters(@NotNull DeclarationDescriptor containingDeclaration, @NotNull PsiTypeParameter[] typeParameters) {
@@ -786,11 +811,20 @@ public class JavaDescriptorResolver {
     }
 
     @Nullable
-    public NamespaceDescriptor resolveNamespace(@NotNull FqName qualifiedName) {
+    public NamespaceDescriptor resolveNamespace(@NotNull FqName qualifiedName, @NotNull DescriptorSearchRule searchRule) {
         // First, let's check that there is no Kotlin package:
         NamespaceDescriptor kotlinNamespaceDescriptor = semanticServices.getKotlinNamespaceDescriptor(qualifiedName);
         if (kotlinNamespaceDescriptor != null) {
-            return kotlinNamespaceDescriptor;
+            if (searchRule == DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN) {
+                throw new IllegalStateException("class must not be found in kotlin: " + qualifiedName);
+            } else if (searchRule == DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN) {
+                return null;
+            } else if (searchRule == DescriptorSearchRule.INCLUDE_KOTLIN) {
+                // TODO: probably this is evil
+                return kotlinNamespaceDescriptor;
+            } else {
+                throw new IllegalStateException("unknown searchRule: " + searchRule);
+            }
         }
 
         PsiPackage psiPackage = findPackage(qualifiedName);
@@ -1445,7 +1479,7 @@ public class JavaDescriptorResolver {
 
         ClassOrNamespaceDescriptor classDescriptor;
         if (scopeData instanceof ResolverBinaryClassData) {
-            ClassDescriptor classClassDescriptor = resolveClass(method.getPsiMethod().getContainingClass());
+            ClassDescriptor classClassDescriptor = resolveClass(method.getPsiMethod().getContainingClass(), DescriptorSearchRule.INCLUDE_KOTLIN);
             classDescriptor = classClassDescriptor;
         }
         else {
@@ -1511,7 +1545,7 @@ public class JavaDescriptorResolver {
             return null;
         }
 
-        ClassDescriptor clazz = resolveClass(new FqName(psiAnnotation.getQualifiedName()));
+        ClassDescriptor clazz = resolveClass(new FqName(psiAnnotation.getQualifiedName()), DescriptorSearchRule.INCLUDE_KOTLIN);
         if (clazz == null) {
             return null;
         }
@@ -1662,7 +1696,7 @@ public class JavaDescriptorResolver {
             if (innerPsiClass.getName().equals(JvmAbi.CLASS_OBJECT_CLASS_NAME)) {
                 continue;
             }
-            r.add(resolveClass(innerPsiClass));
+            r.add(resolveClass(innerPsiClass, DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN));
         }
         return r;
     }

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

@@ -66,7 +66,7 @@ public class JavaPackageScope extends JavaClassOrPackageScope {
 
     @Override
     public ClassifierDescriptor getClassifier(@NotNull String name) {
-        ClassDescriptor classDescriptor = semanticServices.getDescriptorResolver().resolveClass(getQualifiedName(packageFQN, name));
+        ClassDescriptor classDescriptor = semanticServices.getDescriptorResolver().resolveClass(getQualifiedName(packageFQN, name), DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
         if (classDescriptor == null || DescriptorUtils.isObject(classDescriptor)) {
             // TODO: this is a big hack against several things that I barely understand myself and cannot explain
             // 1. We should not return objects from this method, and maybe JDR.resolveClass should not return too
@@ -84,7 +84,7 @@ public class JavaPackageScope extends JavaClassOrPackageScope {
 
     @Override
     public NamespaceDescriptor getNamespace(@NotNull String name) {
-        return semanticServices.getDescriptorResolver().resolveNamespace(getQualifiedName(packageFQN, name));
+        return semanticServices.getDescriptorResolver().resolveNamespace(getQualifiedName(packageFQN, name), DescriptorSearchRule.INCLUDE_KOTLIN);
     }
 
     @Override
@@ -114,8 +114,9 @@ public class JavaPackageScope extends JavaClassOrPackageScope {
                 final JavaDescriptorResolver descriptorResolver = semanticServices.getDescriptorResolver();
 
                 for (PsiPackage psiSubPackage : javaPackage.getSubPackages()) {
-                    if (semanticServices.getKotlinNamespaceDescriptor(new FqName(psiSubPackage.getQualifiedName())) == null) {
-                        allDescriptors.add(descriptorResolver.resolveNamespace(new FqName(psiSubPackage.getQualifiedName())));
+                    NamespaceDescriptor childNs = descriptorResolver.resolveNamespace(new FqName(psiSubPackage.getQualifiedName()), DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN);
+                    if (childNs != null) {
+                        allDescriptors.add(childNs);
                     }
                 }
 
@@ -123,10 +124,8 @@ public class JavaPackageScope extends JavaClassOrPackageScope {
                     if (isKotlinNamespace && JvmAbi.PACKAGE_CLASS.equals(psiClass.getName())) {
                         continue;
                     }
-
-                    // If this is a Kotlin class, we have already taken it through a containing namespace descriptor
-                    ClassDescriptor kotlinClassDescriptor = semanticServices.getKotlinClassDescriptor(new FqName(psiClass.getQualifiedName()));
-                    if (kotlinClassDescriptor != null) {
+                    
+                    if (psiClass instanceof JetJavaMirrorMarker) {
                         continue;
                     }
 
@@ -136,7 +135,7 @@ public class JavaPackageScope extends JavaClassOrPackageScope {
                     }
 
                     if (psiClass.hasModifierProperty(PsiModifier.PUBLIC)) {
-                        ClassDescriptor classDescriptor = descriptorResolver.resolveClass(psiClass);
+                        ClassDescriptor classDescriptor = descriptorResolver.resolveClass(psiClass, DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN);
                         if (classDescriptor != null) {
                             allDescriptors.add(classDescriptor);
                         }

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

@@ -57,15 +57,16 @@ public class JavaSemanticServices {
 
     @Nullable
     public ClassDescriptor getKotlinClassDescriptor(@NotNull FqName qualifiedName) {
+        return getTrace().get(BindingContext.FQNAME_TO_CLASS_DESCRIPTOR, qualifiedName);
+    }
+
+    @Nullable
+    public ClassDescriptor getKotlinBuiltinClassDescriptor(@NotNull FqName qualifiedName) {
         if (qualifiedName.getFqName().startsWith("jet.")) {
-            ClassDescriptor r = (ClassDescriptor) JetStandardLibrary.getInstance().getLibraryScope().getClassifier(qualifiedName.getFqName().substring("jet.".length()));
-            if (r == null) {
-                // TODO: better error
-                //throw new IllegalStateException();
-            }
-            return r;
+            return (ClassDescriptor) JetStandardLibrary.getInstance().getLibraryScope().getClassifier(qualifiedName.getFqName().substring("jet.".length()));
+        } else {
+            return null;
         }
-        return getTrace().get(BindingContext.FQNAME_TO_CLASS_DESCRIPTOR, qualifiedName);
     }
 
     @Nullable

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

@@ -119,7 +119,7 @@ public class JavaTypeTransformer {
                         return jetAnalog;
                     }
 
-                    final JavaDescriptorResolver.ResolverClassData classData = resolver.resolveClassData(psiClass);
+                    final JavaDescriptorResolver.ResolverClassData classData = resolver.resolveClassData(psiClass, DescriptorSearchRule.INCLUDE_KOTLIN);
                     if (classData == null) {
                         return ErrorUtils.createErrorType("Unresolve java class: " + classType.getPresentableText());
                     }

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

@@ -117,7 +117,7 @@ public abstract class JetTypeJetSignatureReader extends JetSignatureExceptionsAd
 
 
         if (this.classDescriptor == null) {
-            this.classDescriptor = javaDescriptorResolver.resolveClass(ourName);
+            this.classDescriptor = javaDescriptorResolver.resolveClass(ourName, DescriptorSearchRule.INCLUDE_KOTLIN);
         }
 
         if (this.classDescriptor == null) {

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

@@ -33,6 +33,7 @@ import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingTraceContext;
 import org.jetbrains.jet.lang.resolve.FqName;
 import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
+import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
 import org.jetbrains.jet.plugin.JetLanguage;
@@ -115,7 +116,7 @@ public class ReadJavaBinaryClassTest extends TestCaseWithTmpdir {
         JavaSemanticServices semanticServices = new JavaSemanticServices(jetCoreEnvironment.getProject(), new BindingTraceContext());
 
         JavaDescriptorResolver javaDescriptorResolver = semanticServices.getDescriptorResolver();
-        return javaDescriptorResolver.resolveNamespace(FqName.topLevel("test"));
+        return javaDescriptorResolver.resolveNamespace(FqName.topLevel("test"), DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN);
     }
 
     public static Test suite() {

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

@@ -35,6 +35,7 @@ import org.jetbrains.jet.lang.resolve.AnalyzingUtils;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingTraceContext;
 import org.jetbrains.jet.lang.resolve.FqName;
+import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
 import org.jetbrains.jet.plugin.JetLanguage;
@@ -93,7 +94,7 @@ public class ReadKotlinBinaryClassTest extends TestCaseWithTmpdir {
         JavaSemanticServices semanticServices = new JavaSemanticServices(jetCoreEnvironment.getProject(), new BindingTraceContext());
 
         JavaDescriptorResolver javaDescriptorResolver = semanticServices.getDescriptorResolver();
-        NamespaceDescriptor namespaceFromClass = javaDescriptorResolver.resolveNamespace(FqName.topLevel("test"));
+        NamespaceDescriptor namespaceFromClass = javaDescriptorResolver.resolveNamespace(FqName.topLevel("test"), DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN);
         
         NamespaceComparator.compareNamespaces(namespaceFromSource, namespaceFromClass, false, txtFile);
     }

compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java

@@ -28,10 +28,7 @@ import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.*;
-import org.jetbrains.jet.lang.resolve.java.JavaBridgeConfiguration;
-import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
-import org.jetbrains.jet.lang.resolve.java.JavaPackageScope;
-import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
+import org.jetbrains.jet.lang.resolve.java.*;
 import org.jetbrains.jet.lang.resolve.scopes.*;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
@@ -588,8 +585,8 @@ public class JetTypeCheckerTest extends JetLiteFixture {
         WritableScopeImpl writableScope = new WritableScopeImpl(scope, scope.getContainingDeclaration(), RedeclarationHandler.DO_NOTHING);
         writableScope.importScope(library.getLibraryScope());
         JavaSemanticServices javaSemanticServices = new JavaSemanticServices(getProject(), JetTestUtils.DUMMY_TRACE);
-        writableScope.importScope(javaSemanticServices.getDescriptorResolver().resolveNamespace(FqName.ROOT).getMemberScope());
-        writableScope.importScope(javaSemanticServices.getDescriptorResolver().resolveNamespace(new FqName("java.lang")).getMemberScope());
+        writableScope.importScope(javaSemanticServices.getDescriptorResolver().resolveNamespace(FqName.ROOT, DescriptorSearchRule.INCLUDE_KOTLIN).getMemberScope());
+        writableScope.importScope(javaSemanticServices.getDescriptorResolver().resolveNamespace(new FqName("java.lang"), DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN).getMemberScope());
         writableScope.changeLockLevel(WritableScope.LockLevel.BOTH);
         return writableScope;
     }

idea/src/org/jetbrains/jet/plugin/libraries/DecompiledDataFactory.java

@@ -32,6 +32,7 @@ import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingTraceContext;
 import org.jetbrains.jet.lang.resolve.FqName;
+import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
 import org.jetbrains.jet.lang.resolve.java.JvmAbi;
@@ -81,7 +82,7 @@ class DecompiledDataFactory {
         PsiClass psiClass = myClsFile.getClasses()[0];
 
         if (isKotlinNamespaceClass(psiClass)) {
-            NamespaceDescriptor nd = myJavaDescriptorResolver.resolveNamespace(new FqName(packageName));
+            NamespaceDescriptor nd = myJavaDescriptorResolver.resolveNamespace(new FqName(packageName), DescriptorSearchRule.INCLUDE_KOTLIN);
 
             if (nd != null) {
                 for (DeclarationDescriptor member : sortDeclarations(nd.getMemberScope().getAllDescriptors())) {
@@ -93,7 +94,7 @@ class DecompiledDataFactory {
                 }
             }
         } else {
-            ClassDescriptor cd = myJavaDescriptorResolver.resolveClass(psiClass);
+            ClassDescriptor cd = myJavaDescriptorResolver.resolveClass(psiClass, DescriptorSearchRule.INCLUDE_KOTLIN);
             if (cd != null) {
                 appendDescriptor(cd, "");
             }

jdk-headers/src/java/util/AbstractMap.kt

 package java.util
 
+import java.util.Map.Entry
+
 abstract public open class AbstractMap<erased K, erased V> protected () : java.lang.Object(), java.util.Map<K, V> {
     override public fun size() : Int {}
     override public fun isEmpty() : Boolean {}
@@ -12,7 +14,7 @@ abstract public open class AbstractMap<erased K, erased V> protected () : java.l
     override public fun clear() : Unit {}
     override public fun keySet() : java.util.Set<K> {}
     override public fun values() : java.util.Collection<V> {}
-    abstract override public fun entrySet() : java.util.Set<java.util.Map.Entry<K, V>>
+    abstract override public fun entrySet() : java.util.Set<Entry<K, V>>
     //override public fun equals(o : Any?) : Boolean
     //override public fun hashCode() : Int
     //override public fun toString() : java.lang.String?

jdk-headers/src/java/util/HashMap.kt

 package java.util
 import java.io.*
+import java.util.Map.Entry
 public open class HashMap<erased K, erased V>(m : java.util.Map<out K, out V>) : java.util.AbstractMap<K, V>(),
                                                                                  java.util.Map<K, V>,
                                                                                  java.lang.Cloneable,
@@ -19,5 +20,5 @@ public open class HashMap<erased K, erased V>(m : java.util.Map<out K, out V>) :
     override public fun clone() : Any? {}
     override public fun keySet() : java.util.Set<K> {}
     override public fun values() : java.util.Collection<V> {}
-    override public fun entrySet() : java.util.Set<java.util.Map.Entry<K, V>> {}
-}
\ No newline at end of file
+    override public fun entrySet() : java.util.Set<Entry<K, V>> {}
+}

jdk-headers/src/java/util/LinkedHashMap.kt

 package java.util
 
+import java.util.Map.Entry
+
 public open class LinkedHashMap<erased K, erased V>(m : java.util.Map<out K, out V>) : java.util.HashMap<K, V>(), java.util.Map<K, V> {
     public this(initialCapacity : Int, loadFactor : Float) {}
     public this(initialCapacity : Int) {}
@@ -8,7 +10,7 @@ public open class LinkedHashMap<erased K, erased V>(m : java.util.Map<out K, out
     override public fun containsValue(value : Any?) : Boolean {}
     override public fun get(key : Any?) : V? {}
     override public fun clear() : Unit {}
-    open protected fun removeEldestEntry(eldest : java.util.Map.Entry<K, V>) : Boolean {}
+    open protected fun removeEldestEntry(eldest : Entry<K, V>) : Boolean {}
     //class object {
     //open public fun init<K, V>(initialCapacity : Int, loadFactor : Float) : LinkedHashMap<K, V> {
     //val __ = LinkedHashMap(0, null, false)
@@ -31,4 +33,4 @@ public open class LinkedHashMap<erased K, erased V>(m : java.util.Map<out K, out
     //return __
     //}
     //}
-}
\ No newline at end of file
+}