azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Converted code to Kotlin (step 1 to keep history)

Browse Source
This commit is contained in:
Valentin Kipyatkov
2015-01-14 17:28:12 +03:00
parent b625298cd4
commit 251d98a602
1 changed files with 67 additions and 110 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend/src/org/jetbrains/kotlin/resolve/Importer.java
+67 -110
View File
@@ -14,148 +14,105 @@
* limitations under the License. * limitations under the License.
*/ */
package org.jetbrains.kotlin.resolve; package org.jetbrains.kotlin.resolve
import com.google.common.collect.Lists; import com.google.common.collect.Lists
import com.intellij.openapi.util.Pair; import com.intellij.openapi.util.Pair
import kotlin.Function1; import org.jetbrains.kotlin.descriptors.*
import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.name.Name
import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap
import org.jetbrains.kotlin.descriptors.*; import org.jetbrains.kotlin.resolve.scopes.FilteringScope
import org.jetbrains.kotlin.name.Name; import org.jetbrains.kotlin.resolve.scopes.JetScope
import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap; import org.jetbrains.kotlin.resolve.scopes.WritableScope
import org.jetbrains.kotlin.resolve.scopes.FilteringScope;
import org.jetbrains.kotlin.resolve.scopes.JetScope;
import org.jetbrains.kotlin.resolve.scopes.WritableScope;
import java.util.Collection; public trait Importer {
import java.util.List; public fun addAllUnderImport(descriptor: DeclarationDescriptor, platformToKotlinClassMap: PlatformToKotlinClassMap)
public interface Importer { public fun addAliasImport(descriptor: DeclarationDescriptor, aliasName: Name)
void addAllUnderImport(@NotNull DeclarationDescriptor descriptor, @NotNull PlatformToKotlinClassMap platformToKotlinClassMap);
void addAliasImport(@NotNull DeclarationDescriptor descriptor, @NotNull Name aliasName); public open class StandardImporter(private val fileScope: WritableScope) : Importer {
Importer DO_NOTHING = new Importer() { override fun addAllUnderImport(descriptor: DeclarationDescriptor, platformToKotlinClassMap: PlatformToKotlinClassMap) {
@Override importAllUnderDeclaration(descriptor, platformToKotlinClassMap)
public void addAllUnderImport(@NotNull DeclarationDescriptor descriptor, @NotNull PlatformToKotlinClassMap platformToKotlinClassMap) {
} }
@Override override fun addAliasImport(descriptor: DeclarationDescriptor, aliasName: Name) {
public void addAliasImport(@NotNull DeclarationDescriptor descriptor, @NotNull Name aliasName) { importDeclarationAlias(descriptor, aliasName)
}
};
class StandardImporter implements Importer {
private final WritableScope fileScope;
public StandardImporter(WritableScope fileScope) {
this.fileScope = fileScope;
} }
@Override protected fun importDeclarationAlias(descriptor: DeclarationDescriptor, aliasName: Name) {
public void addAllUnderImport(@NotNull DeclarationDescriptor descriptor, @NotNull PlatformToKotlinClassMap platformToKotlinClassMap) { if (descriptor is ClassifierDescriptor) {
importAllUnderDeclaration(descriptor, platformToKotlinClassMap); fileScope.importClassifierAlias(aliasName, descriptor)
}
@Override
public void addAliasImport(@NotNull DeclarationDescriptor descriptor, @NotNull Name aliasName) {
importDeclarationAlias(descriptor, aliasName);
}
protected void importDeclarationAlias(@NotNull DeclarationDescriptor descriptor, @NotNull Name aliasName) {
if (descriptor instanceof ClassifierDescriptor) {
fileScope.importClassifierAlias(aliasName, (ClassifierDescriptor) descriptor);
} }
else if (descriptor instanceof PackageViewDescriptor) { else if (descriptor is PackageViewDescriptor) {
fileScope.importPackageAlias(aliasName, (PackageViewDescriptor) descriptor); fileScope.importPackageAlias(aliasName, descriptor)
} }
else if (descriptor instanceof FunctionDescriptor) { else if (descriptor is FunctionDescriptor) {
fileScope.importFunctionAlias(aliasName, (FunctionDescriptor) descriptor); fileScope.importFunctionAlias(aliasName, descriptor)
} }
else if (descriptor instanceof VariableDescriptor) { else if (descriptor is VariableDescriptor) {
fileScope.importVariableAlias(aliasName, (VariableDescriptor) descriptor); fileScope.importVariableAlias(aliasName, descriptor)
} }
} }
protected void importAllUnderDeclaration(@NotNull DeclarationDescriptor descriptor, @NotNull PlatformToKotlinClassMap platformToKotlinClassMap) { protected fun importAllUnderDeclaration(descriptor: DeclarationDescriptor, platformToKotlinClassMap: PlatformToKotlinClassMap) {
if (descriptor instanceof PackageViewDescriptor) { if (descriptor is PackageViewDescriptor) {
NoSubpackagesInPackageScope scope = new NoSubpackagesInPackageScope((PackageViewDescriptor) descriptor); val scope = NoSubpackagesInPackageScope(descriptor)
fileScope.importScope(createFilteringScope(scope, (PackageViewDescriptor) descriptor, platformToKotlinClassMap)); fileScope.importScope(createFilteringScope(scope, descriptor, platformToKotlinClassMap))
} }
else if (descriptor instanceof ClassDescriptor && ((ClassDescriptor) descriptor).getKind() != ClassKind.OBJECT) { else if (descriptor is ClassDescriptor && descriptor.getKind() != ClassKind.OBJECT) {
ClassDescriptor classDescriptor = (ClassDescriptor) descriptor; fileScope.importScope(descriptor.getStaticScope())
fileScope.importScope(classDescriptor.getStaticScope()); fileScope.importScope(descriptor.getUnsubstitutedInnerClassesScope())
fileScope.importScope(classDescriptor.getUnsubstitutedInnerClassesScope()); val classObjectDescriptor = descriptor.getClassObjectDescriptor()
ClassDescriptor classObjectDescriptor = classDescriptor.getClassObjectDescriptor();
if (classObjectDescriptor != null) { if (classObjectDescriptor != null) {
fileScope.importScope(classObjectDescriptor.getUnsubstitutedInnerClassesScope()); fileScope.importScope(classObjectDescriptor.getUnsubstitutedInnerClassesScope())
} }
} }
} }
@NotNull private fun createFilteringScope(scope: JetScope, descriptor: PackageViewDescriptor, platformToKotlinClassMap: PlatformToKotlinClassMap): JetScope {
private static JetScope createFilteringScope( val kotlinAnalogsForClassesInside = platformToKotlinClassMap.mapPlatformClassesInside(descriptor)
@NotNull JetScope scope, if (kotlinAnalogsForClassesInside.isEmpty()) return scope
@NotNull PackageViewDescriptor descriptor, return FilteringScope(scope) { descriptor -> !kotlinAnalogsForClassesInside.any { it.getName() == descriptor.getName() } }
@NotNull PlatformToKotlinClassMap platformToKotlinClassMap
) {
final Collection<ClassDescriptor> kotlinAnalogsForClassesInside = platformToKotlinClassMap.mapPlatformClassesInside(descriptor);
if (kotlinAnalogsForClassesInside.isEmpty()) return scope;
return new FilteringScope(scope, new Function1<DeclarationDescriptor, Boolean>() {
@Override
public Boolean invoke(DeclarationDescriptor descriptor) {
for (ClassDescriptor kotlinAnalog : kotlinAnalogsForClassesInside) {
if (kotlinAnalog.getName().equals(descriptor.getName())) {
return false;
}
}
return true;
}
});
} }
} }
class DelayedImporter extends StandardImporter { public class DelayedImporter(fileScope: WritableScope) : StandardImporter(fileScope) {
private interface DelayedImportEntry {} private trait DelayedImportEntry
private static class AllUnderImportEntry extends Pair<DeclarationDescriptor, PlatformToKotlinClassMap> implements DelayedImportEntry { private class AllUnderImportEntry(first: DeclarationDescriptor, second: PlatformToKotlinClassMap?) : Pair<DeclarationDescriptor, PlatformToKotlinClassMap>(first, second), DelayedImportEntry
public AllUnderImportEntry(@NotNull DeclarationDescriptor first, @Nullable PlatformToKotlinClassMap second) { private class AliasImportEntry(first: DeclarationDescriptor, second: Name) : Pair<DeclarationDescriptor, Name>(first, second), DelayedImportEntry
super(first, second);
} private val imports = Lists.newArrayList<DelayedImportEntry>()
}
private static class AliasImportEntry extends Pair<DeclarationDescriptor, Name> implements DelayedImportEntry { override fun addAllUnderImport(descriptor: DeclarationDescriptor, platformToKotlinClassMap: PlatformToKotlinClassMap) {
public AliasImportEntry(DeclarationDescriptor first, Name second) { imports.add(AllUnderImportEntry(descriptor, platformToKotlinClassMap))
super(first, second);
}
} }
private final List<DelayedImportEntry> imports = Lists.newArrayList(); override fun addAliasImport(descriptor: DeclarationDescriptor, aliasName: Name) {
imports.add(AliasImportEntry(descriptor, aliasName))
public DelayedImporter(@NotNull WritableScope fileScope) {
super(fileScope);
} }
@Override public fun processImports() {
public void addAllUnderImport(@NotNull DeclarationDescriptor descriptor, @NotNull PlatformToKotlinClassMap platformToKotlinClassMap) { for (anImport in imports) {
imports.add(new AllUnderImportEntry(descriptor, platformToKotlinClassMap)); if (anImport is AllUnderImportEntry) {
} val allUnderImportEntry = anImport as AllUnderImportEntry
importAllUnderDeclaration(allUnderImportEntry.getFirst(), allUnderImportEntry.getSecond())
@Override
public void addAliasImport(@NotNull DeclarationDescriptor descriptor, @NotNull Name aliasName) {
imports.add(new AliasImportEntry(descriptor, aliasName));
}
public void processImports() {
for (DelayedImportEntry anImport : imports) {
if (anImport instanceof AllUnderImportEntry) {
AllUnderImportEntry allUnderImportEntry = (AllUnderImportEntry) anImport;
importAllUnderDeclaration(allUnderImportEntry.getFirst(), allUnderImportEntry.getSecond());
} }
else { else {
AliasImportEntry aliasImportEntry = (AliasImportEntry) anImport; val aliasImportEntry = anImport as AliasImportEntry
importDeclarationAlias(aliasImportEntry.getFirst(), aliasImportEntry.getSecond()); importDeclarationAlias(aliasImportEntry.getFirst(), aliasImportEntry.getSecond())
} }
} }
} }
} }
class object {
public val DO_NOTHING: Importer = object : Importer {
override fun addAllUnderImport(descriptor: DeclarationDescriptor, platformToKotlinClassMap: PlatformToKotlinClassMap) {
}
override fun addAliasImport(descriptor: DeclarationDescriptor, aliasName: Name) {
}
}
}
} }