From 3bd79fa7010691d8ac333425fe4e53863ad48b8e Mon Sep 17 00:00:00 2001 From: Svetlana Isakova Date: Fri, 7 Sep 2012 18:19:04 +0400 Subject: [PATCH] introduced interface PlatformToKotlinClassMap changed method in ModuleConfiguration (now it returns PlatformToKotlinClassMap) JavaToKotlinTypesMap implements PlatformToKotlinClassMap 'importAllUnderDeclaration' in Importer uses PlatformToKotlinClassMap --- .../resolve/java/JavaBridgeConfiguration.java | 16 ++---- ...ypesMap.java => JavaToKotlinClassMap.java} | 41 +++++++++++----- .../resolve/java/JavaTypeTransformer.java | 10 ++-- .../java/JetTypeJetSignatureReader.java | 3 +- .../jet/analyzer/AnalyzeExhaust.java | 8 ++- .../jet/lang/DefaultModuleConfiguration.java | 7 +-- .../jet/lang/ModuleConfiguration.java | 9 ++-- .../jet/lang/PlatformToKotlinClassMap.java | 49 +++++++++++++++++++ .../jetbrains/jet/lang/resolve/Importer.java | 47 +++++++++++++----- .../jet/lang/resolve/ImportsResolver.java | 23 ++++----- .../resolve/QualifiedExpressionResolver.java | 2 +- .../jet/lang/resolve/TypeResolver.java | 6 +-- .../lazy/LazyResolveBuiltinClassesTest.java | 10 ++-- .../resolve/lazy/LazyResolveTestUtil.java | 7 ++- .../project/AnalyzerFacadeWithCache.java | 7 ++- .../k2js/analyze/JsConfiguration.java | 8 ++- 16 files changed, 156 insertions(+), 97 deletions(-) rename compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/{JavaToKotlinTypesMap.java => JavaToKotlinClassMap.java} (81%) create mode 100644 compiler/frontend/src/org/jetbrains/jet/lang/PlatformToKotlinClassMap.java diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaBridgeConfiguration.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaBridgeConfiguration.java index ad648e2fc44..3164c1999d8 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaBridgeConfiguration.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaBridgeConfiguration.java @@ -20,22 +20,20 @@ import com.intellij.openapi.project.Project; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.BuiltinsScopeExtensionMode; import org.jetbrains.jet.lang.DefaultModuleConfiguration; +import org.jetbrains.jet.lang.PlatformToKotlinClassMap; import org.jetbrains.jet.lang.ModuleConfiguration; -import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; import org.jetbrains.jet.lang.psi.JetImportDirective; import org.jetbrains.jet.lang.psi.JetPsiFactory; import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.ImportPath; -import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; import javax.annotation.PostConstruct; import javax.inject.Inject; import java.util.Collection; -import java.util.Collections; /** * @author abreslav @@ -91,15 +89,7 @@ public class JavaBridgeConfiguration implements ModuleConfiguration { @NotNull @Override - public Collection getKotlinAnalogs(@NotNull FqNameUnsafe classOrPackageName) { - return getKotlinAnalogsForJavaStandardClasses(classOrPackageName); - } - - @NotNull - public static Collection getKotlinAnalogsForJavaStandardClasses(@NotNull FqNameUnsafe classOrPackageName) { - if (classOrPackageName.isSafe()) { - return JavaToKotlinTypesMap.getInstance().getAllKotlinAnalogs(classOrPackageName.toSafe()); - } - return Collections.emptyList(); + public PlatformToKotlinClassMap getPlatformToKotlinClassMap() { + return JavaToKotlinClassMap.getInstance(); } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaToKotlinTypesMap.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaToKotlinClassMap.java similarity index 81% rename from compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaToKotlinTypesMap.java rename to compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaToKotlinClassMap.java index 55195bcacef..1642b77c6b6 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaToKotlinTypesMap.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaToKotlinClassMap.java @@ -19,8 +19,12 @@ package org.jetbrains.jet.lang.resolve.java; import com.google.common.collect.*; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.lang.PlatformToKotlinClassMap; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; +import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; +import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.name.FqName; +import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.lang.JetStandardClasses; import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; @@ -32,13 +36,13 @@ import java.util.*; /** * @author svtk */ -public class JavaToKotlinTypesMap { - private static JavaToKotlinTypesMap instance = null; +public class JavaToKotlinClassMap implements PlatformToKotlinClassMap { + private static JavaToKotlinClassMap instance = null; @NotNull - public static JavaToKotlinTypesMap getInstance() { + public static JavaToKotlinClassMap getInstance() { if (instance == null) { - instance = new JavaToKotlinTypesMap(); + instance = new JavaToKotlinClassMap(); } return instance; } @@ -48,7 +52,7 @@ public class JavaToKotlinTypesMap { private final Map primitiveTypesMap = Maps.newHashMap(); private final Multimap packagesWithMappedClasses = HashMultimap.create(); - private JavaToKotlinTypesMap() { + private JavaToKotlinClassMap() { init(); initPrimitives(); } @@ -107,12 +111,12 @@ public class JavaToKotlinTypesMap { } @Nullable - public JetType getPrimitiveKotlinAnalog(@NotNull String name) { + public JetType mapPrimitiveKotlinClass(@NotNull String name) { return primitiveTypesMap.get(name); } @Nullable - public ClassDescriptor getKotlinAnalog(@NotNull FqName fqName, @NotNull JavaTypeTransformer.TypeUsage typeUsage) { + public ClassDescriptor mapKotlinClass(@NotNull FqName fqName, @NotNull JavaTypeTransformer.TypeUsage typeUsage) { if (typeUsage == JavaTypeTransformer.TypeUsage.MEMBER_SIGNATURE_COVARIANT || typeUsage == JavaTypeTransformer.TypeUsage.SUPERTYPE) { ClassDescriptor descriptor = classDescriptorMapForCovariantPositions.get(fqName); @@ -145,14 +149,17 @@ public class JavaToKotlinTypesMap { packagesWithMappedClasses.put(javaClassName.parent(), kotlinDescriptor); } + @Override @NotNull - public Collection getAllKotlinAnalogs(@NotNull FqName fqName) { + public Collection mapPlatformClass(@NotNull ClassDescriptor classDescriptor) { + FqNameUnsafe className = DescriptorUtils.getFQName(classDescriptor); + if (!className.isSafe()) { + return Collections.emptyList(); + } + FqName fqName = className.toSafe(); ClassDescriptor kotlinAnalog = classDescriptorMap.get(fqName); ClassDescriptor kotlinCovariantAnalog = classDescriptorMapForCovariantPositions.get(fqName); - if (kotlinAnalog == null && kotlinCovariantAnalog == null) { - return packagesWithMappedClasses.get(fqName); - } - ArrayList descriptors = Lists.newArrayList(); + List descriptors = Lists.newArrayList(); if (kotlinAnalog != null) { descriptors.add(kotlinAnalog); } @@ -161,4 +168,14 @@ public class JavaToKotlinTypesMap { } return descriptors; } + + @Override + @NotNull + public Collection mapPlatformClassesInside(@NotNull DeclarationDescriptor containingDeclaration) { + FqNameUnsafe fqName = DescriptorUtils.getFQName(containingDeclaration); + if (!fqName.isSafe()) { + return Collections.emptyList(); + } + return packagesWithMappedClasses.get(fqName.toSafe()); + } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaTypeTransformer.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaTypeTransformer.java index c4b6725a790..b271bbe4b40 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaTypeTransformer.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaTypeTransformer.java @@ -26,9 +26,7 @@ import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.types.*; import org.jetbrains.jet.lang.types.checker.JetTypeChecker; -import org.jetbrains.jet.lang.types.lang.JetStandardClasses; import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; -import org.jetbrains.jet.lang.types.lang.PrimitiveType; import org.jetbrains.jet.rt.signature.JetSignatureReader; import javax.inject.Inject; @@ -149,8 +147,8 @@ public class JavaTypeTransformer { // 'L extends List' in Java is a List in Kotlin, not a List boolean nullable = !EnumSet.of(SUPERTYPE_ARGUMENT, SUPERTYPE).contains(howThisTypeIsUsed); - ClassDescriptor classData = JavaToKotlinTypesMap.getInstance().getKotlinAnalog(new FqName(psiClass.getQualifiedName()), - howThisTypeIsUsed); + ClassDescriptor classData = JavaToKotlinClassMap.getInstance().mapKotlinClass(new FqName(psiClass.getQualifiedName()), + howThisTypeIsUsed); if (classData == null) { classData = resolver.resolveClass(new FqName(psiClass.getQualifiedName()), DescriptorSearchRule.INCLUDE_KOTLIN); @@ -197,7 +195,7 @@ public class JavaTypeTransformer { @Override public JetType visitPrimitiveType(PsiPrimitiveType primitiveType) { String canonicalText = primitiveType.getCanonicalText(); - JetType type = JavaToKotlinTypesMap.getInstance().getPrimitiveKotlinAnalog(canonicalText); + JetType type = JavaToKotlinClassMap.getInstance().mapPrimitiveKotlinClass(canonicalText); assert type != null : canonicalText; return type; } @@ -206,7 +204,7 @@ public class JavaTypeTransformer { public JetType visitArrayType(PsiArrayType arrayType) { PsiType componentType = arrayType.getComponentType(); if (componentType instanceof PsiPrimitiveType) { - JetType jetType = JavaToKotlinTypesMap.getInstance().getPrimitiveKotlinAnalog("[" + componentType.getCanonicalText()); + JetType jetType = JavaToKotlinClassMap.getInstance().mapPrimitiveKotlinClass("[" + componentType.getCanonicalText()); if (jetType != null) return TypeUtils.makeNullable(jetType); } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JetTypeJetSignatureReader.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JetTypeJetSignatureReader.java index a2eff386569..8e34d09bba8 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JetTypeJetSignatureReader.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JetTypeJetSignatureReader.java @@ -95,7 +95,8 @@ public abstract class JetTypeJetSignatureReader extends JetSignatureExceptionsAd this.classDescriptor = null; if (!forceReal) { - classDescriptor = JavaToKotlinTypesMap.getInstance().getKotlinAnalog(ourName, JavaTypeTransformer.TypeUsage.MEMBER_SIGNATURE_INVARIANT); + classDescriptor = JavaToKotlinClassMap.getInstance().mapKotlinClass(ourName, + JavaTypeTransformer.TypeUsage.MEMBER_SIGNATURE_INVARIANT); } if (classDescriptor == null) { diff --git a/compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzeExhaust.java b/compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzeExhaust.java index 13466bd6c89..637b3f44cee 100644 --- a/compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzeExhaust.java +++ b/compiler/frontend/src/org/jetbrains/jet/analyzer/AnalyzeExhaust.java @@ -18,18 +18,16 @@ package org.jetbrains.jet.analyzer; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.lang.PlatformToKotlinClassMap; import org.jetbrains.jet.lang.ModuleConfiguration; -import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; import org.jetbrains.jet.lang.psi.JetImportDirective; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.BodiesResolveContext; -import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; import java.util.Collection; -import java.util.Collections; /** * @author Stepan Koltsov @@ -46,8 +44,8 @@ public class AnalyzeExhaust { @NotNull @Override - public Collection getKotlinAnalogs(@NotNull FqNameUnsafe classOrPackageName) { - return Collections.emptyList(); + public PlatformToKotlinClassMap getPlatformToKotlinClassMap() { + return PlatformToKotlinClassMap.EMPTY; } @Override diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/DefaultModuleConfiguration.java b/compiler/frontend/src/org/jetbrains/jet/lang/DefaultModuleConfiguration.java index 605ae56d13e..1dea916ef01 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/DefaultModuleConfiguration.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/DefaultModuleConfiguration.java @@ -18,20 +18,17 @@ package org.jetbrains.jet.lang; import com.intellij.openapi.project.Project; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; import org.jetbrains.jet.lang.psi.JetImportDirective; import org.jetbrains.jet.lang.psi.JetPsiFactory; import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.ImportPath; -import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; import org.jetbrains.jet.lang.types.lang.JetStandardClasses; import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; import java.util.Collection; -import java.util.Collections; /** * @author svtk @@ -76,7 +73,7 @@ public class DefaultModuleConfiguration implements ModuleConfiguration { @NotNull @Override - public Collection getKotlinAnalogs(@NotNull FqNameUnsafe classOrPackageName) { - return Collections.emptyList(); + public PlatformToKotlinClassMap getPlatformToKotlinClassMap() { + return PlatformToKotlinClassMap.EMPTY; } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/ModuleConfiguration.java b/compiler/frontend/src/org/jetbrains/jet/lang/ModuleConfiguration.java index c7480d3372b..d32476f6243 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/ModuleConfiguration.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/ModuleConfiguration.java @@ -17,15 +17,12 @@ package org.jetbrains.jet.lang; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; import org.jetbrains.jet.lang.psi.JetImportDirective; import org.jetbrains.jet.lang.resolve.BindingTrace; -import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; import java.util.Collection; -import java.util.Collections; /** * @author abreslav @@ -42,8 +39,8 @@ public interface ModuleConfiguration { @NotNull @Override - public Collection getKotlinAnalogs(@NotNull FqNameUnsafe classOrPackageName) { - return Collections.emptyList(); + public PlatformToKotlinClassMap getPlatformToKotlinClassMap() { + return PlatformToKotlinClassMap.EMPTY; } @Override @@ -61,5 +58,5 @@ public interface ModuleConfiguration { void extendNamespaceScope(@NotNull BindingTrace trace, @NotNull NamespaceDescriptor namespaceDescriptor, @NotNull WritableScope namespaceMemberScope); @NotNull - Collection getKotlinAnalogs(@NotNull FqNameUnsafe classOrPackageName); + PlatformToKotlinClassMap getPlatformToKotlinClassMap(); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/PlatformToKotlinClassMap.java b/compiler/frontend/src/org/jetbrains/jet/lang/PlatformToKotlinClassMap.java new file mode 100644 index 00000000000..a44001c3b1c --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/PlatformToKotlinClassMap.java @@ -0,0 +1,49 @@ +/* + * 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; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.descriptors.ClassDescriptor; +import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; + +import java.util.Collection; +import java.util.Collections; + +/** +* @author svtk +*/ +public interface PlatformToKotlinClassMap { + PlatformToKotlinClassMap EMPTY = new PlatformToKotlinClassMap() { + @NotNull + @Override + public Collection mapPlatformClass(@NotNull ClassDescriptor classDescriptor) { + return Collections.emptyList(); + } + + @NotNull + @Override + public Collection mapPlatformClassesInside(@NotNull DeclarationDescriptor containingDeclaration) { + return Collections.emptyList(); + } + }; + + @NotNull + Collection mapPlatformClass(@NotNull ClassDescriptor classDescriptor); + + @NotNull + Collection mapPlatformClassesInside(@NotNull DeclarationDescriptor containingDeclaration); +} 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 90a1c1bbb98..4bb23ad1645 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/Importer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/Importer.java @@ -21,12 +21,14 @@ import com.google.common.collect.Lists; import com.intellij.openapi.util.Pair; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.lang.PlatformToKotlinClassMap; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.FilteringScope; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; +import java.util.Collection; import java.util.List; /** @@ -34,13 +36,13 @@ import java.util.List; */ /*package*/ interface Importer { - void addAllUnderImport(@NotNull DeclarationDescriptor descriptor, @Nullable Predicate isNotHiddenByKotlinAnalog); + void addAllUnderImport(@NotNull DeclarationDescriptor descriptor, @NotNull PlatformToKotlinClassMap platformToKotlinClassMap); void addAliasImport(@NotNull DeclarationDescriptor descriptor, @NotNull Name aliasName); Importer DO_NOTHING = new Importer() { @Override - public void addAllUnderImport(@NotNull DeclarationDescriptor descriptor, Predicate isNotHiddenByKotlinAnalog) { + public void addAllUnderImport(@NotNull DeclarationDescriptor descriptor, @NotNull PlatformToKotlinClassMap platformToKotlinClassMap) { } @Override @@ -56,8 +58,8 @@ import java.util.List; } @Override - public void addAllUnderImport(@NotNull DeclarationDescriptor descriptor, @Nullable Predicate isNotHiddenByKotlinAnalog) { - importAllUnderDeclaration(descriptor, isNotHiddenByKotlinAnalog); + public void addAllUnderImport(@NotNull DeclarationDescriptor descriptor, @NotNull PlatformToKotlinClassMap platformToKotlinClassMap) { + importAllUnderDeclaration(descriptor, platformToKotlinClassMap); } @Override @@ -65,7 +67,29 @@ import java.util.List; importDeclarationAlias(descriptor, aliasName); } - protected void importAllUnderDeclaration(@NotNull DeclarationDescriptor descriptor, @Nullable Predicate isNotHiddenByKotlinAnalog) { + @NotNull + private static JetScope createFilteringScope( + @NotNull JetScope scope, + @NotNull DeclarationDescriptor descriptor, + @NotNull PlatformToKotlinClassMap platformToKotlinClassMap + ) { + final Collection kotlinAnalogsForClassesInside = platformToKotlinClassMap.mapPlatformClassesInside( + descriptor); + if (kotlinAnalogsForClassesInside.isEmpty()) return scope; + return new FilteringScope(scope, new Predicate() { + @Override + public boolean apply(DeclarationDescriptor descriptor) { + for (ClassDescriptor kotlinAnalog : kotlinAnalogsForClassesInside) { + if (kotlinAnalog.getName().equals(descriptor.getName())) { + return false; + } + } + return true; + } + }); + } + + protected void importAllUnderDeclaration(@NotNull DeclarationDescriptor descriptor, @NotNull PlatformToKotlinClassMap platformToKotlinClassMap) { JetScope scopeToImport = null; if (descriptor instanceof NamespaceDescriptor) { scopeToImport = ((NamespaceDescriptor) descriptor).getMemberScope(); @@ -79,10 +103,7 @@ import java.util.List; } } if (scopeToImport != null) { - if (isNotHiddenByKotlinAnalog != null) { - scopeToImport = new FilteringScope(scopeToImport, isNotHiddenByKotlinAnalog); - } - namespaceScope.importScope(scopeToImport); + namespaceScope.importScope(createFilteringScope(scopeToImport, descriptor, platformToKotlinClassMap)); } } @@ -105,8 +126,8 @@ import java.util.List; class DelayedImporter extends StandardImporter { private interface DelayedImportEntry {} - private static class AllUnderImportEntry extends Pair> implements DelayedImportEntry { - public AllUnderImportEntry(@NotNull DeclarationDescriptor first, @Nullable Predicate second) { + private static class AllUnderImportEntry extends Pair implements DelayedImportEntry { + public AllUnderImportEntry(@NotNull DeclarationDescriptor first, @Nullable PlatformToKotlinClassMap second) { super(first, second); } } @@ -123,8 +144,8 @@ import java.util.List; } @Override - public void addAllUnderImport(@NotNull DeclarationDescriptor descriptor, @Nullable Predicate isNotHiddenByKotlinAnalog) { - imports.add(new AllUnderImportEntry(descriptor, isNotHiddenByKotlinAnalog)); + public void addAllUnderImport(@NotNull DeclarationDescriptor descriptor, @NotNull PlatformToKotlinClassMap platformToKotlinClassMap) { + imports.add(new AllUnderImportEntry(descriptor, platformToKotlinClassMap)); } @Override diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java index 7e1537cbb18..7290d65ed46 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java @@ -19,10 +19,10 @@ package org.jetbrains.jet.lang.resolve; import com.google.common.collect.Lists; import com.google.common.collect.Maps; import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.PlatformToKotlinClassMap; import org.jetbrains.jet.lang.ModuleConfiguration; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.*; -import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; @@ -124,7 +124,9 @@ public class ImportsResolver { resolvedDirectives.put(importDirective, descriptors.iterator().next()); } for (DeclarationDescriptor descriptor : descriptors) { - reportHasKotlinAnalog(onlyClasses, configuration, trace, importDirective, descriptor); + JetExpression importedReference = importDirective.getImportedReference(); + if (onlyClasses || importedReference == null) continue; + reportPlatformClassMappedToKotlin(configuration, trace, importedReference, descriptor); } } delayedImporter.processImports(); @@ -136,19 +138,18 @@ public class ImportsResolver { } } - private static void reportHasKotlinAnalog( - boolean onlyClasses, + public static void reportPlatformClassMappedToKotlin( @NotNull ModuleConfiguration configuration, @NotNull BindingTrace trace, - @NotNull JetImportDirective importDirective, + @NotNull JetElement element, @NotNull DeclarationDescriptor descriptor ) { - if (!(descriptor instanceof ClassDescriptor) || onlyClasses) return; - FqNameUnsafe fqName = DescriptorUtils.getFQName(descriptor); - Collection kotlinAnalogs = configuration.getKotlinAnalogs(fqName); - JetExpression importedReference = importDirective.getImportedReference(); - if (importedReference != null && !kotlinAnalogs.isEmpty()) { - trace.report(CLASS_HAS_KOTLIN_ANALOG.on(importedReference, kotlinAnalogs)); + if (!(descriptor instanceof ClassDescriptor)) return; + + PlatformToKotlinClassMap platformToKotlinMap = configuration.getPlatformToKotlinClassMap(); + Collection kotlinAnalogsForClass = platformToKotlinMap.mapPlatformClass((ClassDescriptor) descriptor); + if (!kotlinAnalogsForClass.isEmpty()) { + trace.report(CLASS_HAS_KOTLIN_ANALOG.on(element, kotlinAnalogsForClass)); } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/QualifiedExpressionResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/QualifiedExpressionResolver.java index f8178d27572..292b6991ab7 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/QualifiedExpressionResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/QualifiedExpressionResolver.java @@ -85,7 +85,7 @@ public class QualifiedExpressionResolver { } for (DeclarationDescriptor descriptor : descriptors) { - importer.addAllUnderImport(descriptor, DescriptorUtils.createIsNotHiddenByKotlinAnalogPredicate(descriptor, moduleConfiguration)); + importer.addAllUnderImport(descriptor, moduleConfiguration.getPlatformToKotlinClassMap()); } return Collections.emptyList(); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.java index d3965d86c05..71576375ebe 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeResolver.java @@ -37,7 +37,6 @@ import java.util.Collection; import java.util.Collections; import java.util.List; -import static org.jetbrains.jet.lang.diagnostics.Errors.CLASS_HAS_KOTLIN_ANALOG; import static org.jetbrains.jet.lang.diagnostics.Errors.UNSUPPORTED; import static org.jetbrains.jet.lang.diagnostics.Errors.WRONG_NUMBER_OF_TYPE_ARGUMENTS; @@ -289,10 +288,7 @@ public class TypeResolver { Collection descriptors = qualifiedExpressionResolver.lookupDescriptorsForUserType(userType, scope, trace); for (DeclarationDescriptor descriptor : descriptors) { if (descriptor instanceof ClassifierDescriptor) { - Collection kotlinAnalogs = moduleConfiguration.getKotlinAnalogs(DescriptorUtils.getFQName(descriptor)); - if (!kotlinAnalogs.isEmpty()) { - trace.report(CLASS_HAS_KOTLIN_ANALOG.on(userType, kotlinAnalogs)); - } + ImportsResolver.reportPlatformClassMappedToKotlin(moduleConfiguration, trace, userType, descriptor); return (ClassifierDescriptor) descriptor; } } diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveBuiltinClassesTest.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveBuiltinClassesTest.java index 094845aafd4..faf0c35645f 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveBuiltinClassesTest.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveBuiltinClassesTest.java @@ -25,9 +25,8 @@ import com.intellij.util.Function; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.ConfigurationKind; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; -import org.jetbrains.jet.lang.descriptors.ClassDescriptor; -import org.jetbrains.jet.lang.resolve.java.JavaBridgeConfiguration; -import org.jetbrains.jet.lang.resolve.java.JavaToKotlinTypesMap; +import org.jetbrains.jet.lang.PlatformToKotlinClassMap; +import org.jetbrains.jet.lang.resolve.java.JavaToKotlinClassMap; import org.jetbrains.jet.test.util.NamespaceComparator; import org.jetbrains.jet.lang.DefaultModuleConfiguration; import org.jetbrains.jet.lang.ModuleConfiguration; @@ -48,7 +47,6 @@ import org.junit.Test; import java.io.File; import java.io.IOException; import java.util.Collection; -import java.util.Collections; import java.util.List; import java.util.Map; @@ -121,8 +119,8 @@ public class LazyResolveBuiltinClassesTest extends KotlinTestWithEnvironment { @NotNull @Override - public Collection getKotlinAnalogs(@NotNull FqNameUnsafe classOrPackageName) { - return JavaBridgeConfiguration.getKotlinAnalogsForJavaStandardClasses(classOrPackageName); + public PlatformToKotlinClassMap getPlatformToKotlinClassMap() { + return JavaToKotlinClassMap.getInstance(); } } } diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java index 7ac7eb5ff8c..2d15b0a9929 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java @@ -28,15 +28,14 @@ import org.jetbrains.jet.di.InjectorForTopDownAnalyzer; import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm; import org.jetbrains.jet.lang.BuiltinsScopeExtensionMode; import org.jetbrains.jet.lang.DefaultModuleConfiguration; +import org.jetbrains.jet.lang.PlatformToKotlinClassMap; import org.jetbrains.jet.lang.ModuleConfiguration; -import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.*; import org.jetbrains.jet.lang.resolve.java.*; import org.jetbrains.jet.lang.resolve.name.FqName; -import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; @@ -118,8 +117,8 @@ public class LazyResolveTestUtil { @NotNull @Override - public Collection getKotlinAnalogs(@NotNull FqNameUnsafe classOrPackageName) { - return JavaBridgeConfiguration.getKotlinAnalogsForJavaStandardClasses(classOrPackageName); + public PlatformToKotlinClassMap getPlatformToKotlinClassMap() { + return JavaToKotlinClassMap.getInstance(); } }; diff --git a/idea/src/org/jetbrains/jet/plugin/project/AnalyzerFacadeWithCache.java b/idea/src/org/jetbrains/jet/plugin/project/AnalyzerFacadeWithCache.java index d19ec091013..4dade77dd64 100644 --- a/idea/src/org/jetbrains/jet/plugin/project/AnalyzerFacadeWithCache.java +++ b/idea/src/org/jetbrains/jet/plugin/project/AnalyzerFacadeWithCache.java @@ -37,8 +37,8 @@ import org.jetbrains.jet.analyzer.AnalyzeExhaust; import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver; import org.jetbrains.jet.lang.BuiltinsScopeExtensionMode; import org.jetbrains.jet.lang.DefaultModuleConfiguration; +import org.jetbrains.jet.lang.PlatformToKotlinClassMap; import org.jetbrains.jet.lang.ModuleConfiguration; -import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils; @@ -51,7 +51,6 @@ import org.jetbrains.jet.lang.resolve.java.*; import org.jetbrains.jet.lang.resolve.lazy.FileBasedDeclarationProviderFactory; import org.jetbrains.jet.lang.resolve.lazy.ResolveSession; import org.jetbrains.jet.lang.resolve.name.FqName; -import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; @@ -243,8 +242,8 @@ public final class AnalyzerFacadeWithCache { @NotNull @Override - public Collection getKotlinAnalogs(@NotNull FqNameUnsafe className) { - return Collections.emptyList(); + public PlatformToKotlinClassMap getPlatformToKotlinClassMap() { + return PlatformToKotlinClassMap.EMPTY; } }; diff --git a/js/js.translator/src/org/jetbrains/k2js/analyze/JsConfiguration.java b/js/js.translator/src/org/jetbrains/k2js/analyze/JsConfiguration.java index a6c78c52100..792b542e7f3 100644 --- a/js/js.translator/src/org/jetbrains/k2js/analyze/JsConfiguration.java +++ b/js/js.translator/src/org/jetbrains/k2js/analyze/JsConfiguration.java @@ -21,8 +21,8 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.BuiltinsScopeExtensionMode; import org.jetbrains.jet.lang.DefaultModuleConfiguration; +import org.jetbrains.jet.lang.PlatformToKotlinClassMap; import org.jetbrains.jet.lang.ModuleConfiguration; -import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; import org.jetbrains.jet.lang.psi.JetImportDirective; import org.jetbrains.jet.lang.psi.JetPsiFactory; @@ -31,13 +31,11 @@ import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.ImportPath; import org.jetbrains.jet.lang.resolve.name.FqName; -import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; import org.jetbrains.jet.lang.types.lang.JetStandardClasses; import java.util.Arrays; import java.util.Collection; -import java.util.Collections; import java.util.List; import static org.jetbrains.jet.lang.resolve.DescriptorUtils.isRootNamespace; @@ -108,7 +106,7 @@ public final class JsConfiguration implements ModuleConfiguration { @NotNull @Override - public Collection getKotlinAnalogs(@NotNull FqNameUnsafe classOrPackageName) { - return Collections.emptyList(); + public PlatformToKotlinClassMap getPlatformToKotlinClassMap() { + return PlatformToKotlinClassMap.EMPTY; } }