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

Unused code removed from ImportsResolver

Browse Source
This commit is contained in:
Andrey Breslav
2015-01-23 19:18:24 +03:00
parent 51c1e1268e
commit 794bb07eb5
1 changed files with 10 additions and 111 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend/src/org/jetbrains/kotlin/resolve/ImportsResolver.java
+10 -111
View File
@@ -16,127 +16,26 @@
package org.jetbrains.kotlin.resolve;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.kotlin.descriptors.*;
import org.jetbrains.kotlin.descriptors.impl.ScriptDescriptorImpl;
import org.jetbrains.kotlin.descriptors.ClassDescriptor;
import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
import org.jetbrains.kotlin.descriptors.PackageViewDescriptor;
import org.jetbrains.kotlin.name.Name;
import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap;
import org.jetbrains.kotlin.psi.*;
import org.jetbrains.kotlin.psi.JetElement;
import org.jetbrains.kotlin.psi.JetExpression;
import org.jetbrains.kotlin.psi.JetImportDirective;
import org.jetbrains.kotlin.psi.JetPsiUtil;
import org.jetbrains.kotlin.resolve.scopes.JetScope;
import org.jetbrains.kotlin.resolve.scopes.WritableScope;
import javax.inject.Inject;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import static org.jetbrains.kotlin.diagnostics.Errors.*;
import static org.jetbrains.kotlin.resolve.QualifiedExpressionResolver.LookupMode;
import static org.jetbrains.kotlin.diagnostics.Errors.CONFLICTING_IMPORT;
import static org.jetbrains.kotlin.diagnostics.Errors.PLATFORM_CLASS_MAPPED_TO_KOTLIN;
public class ImportsResolver {
private ModuleDescriptor moduleDescriptor;
private QualifiedExpressionResolver qualifiedExpressionResolver;
private BindingTrace trace;
private JetImportsFactory importsFactory;
@Inject
public void setModuleDescriptor(@NotNull ModuleDescriptor moduleDescriptor) {
this.moduleDescriptor = moduleDescriptor;
}
@Inject
public void setTrace(@NotNull BindingTrace trace) {
this.trace = trace;
}
@Inject
public void setQualifiedExpressionResolver(@NotNull QualifiedExpressionResolver qualifiedExpressionResolver) {
this.qualifiedExpressionResolver = qualifiedExpressionResolver;
}
@Inject
public void setImportsFactory(@NotNull JetImportsFactory importsFactory) {
this.importsFactory = importsFactory;
}
public void processTypeImports(@NotNull TopDownAnalysisContext c) {
processImports(c, LookupMode.ONLY_CLASSES_AND_PACKAGES);
}
public void processMembersImports(@NotNull TopDownAnalysisContext c) {
processImports(c, LookupMode.EVERYTHING);
}
private void processImports(@NotNull TopDownAnalysisContext c, @NotNull LookupMode lookupMode) {
for (JetFile file : c.getFiles()) {
if (file.isScript()) continue;
WritableScope fileScope = c.getFileScopes().get(file);
processImportsInFile(lookupMode, fileScope, Lists.newArrayList(file.getImportDirectives()), file.getPackageFqName().isRoot());
}
// SCRIPT: process script import directives
for (JetScript script : c.getScripts().keySet()) {
WritableScope scriptScope = ((ScriptDescriptorImpl) c.getScripts().get(script)).getScopeForBodyResolution();
processImportsInFile(lookupMode, scriptScope, script.getContainingJetFile().getImportDirectives(), true);
}
}
private void processImportsInFile(@NotNull LookupMode lookupMode, WritableScope scope, List<JetImportDirective> directives, boolean inRootPackage) {
processImportsInFile(lookupMode, scope, directives, moduleDescriptor, trace, qualifiedExpressionResolver, importsFactory, inRootPackage);
}
private static void processImportsInFile(
LookupMode lookupMode,
@NotNull WritableScope fileScope,
@NotNull List<JetImportDirective> importDirectives,
@NotNull ModuleDescriptor module,
@NotNull BindingTrace trace,
@NotNull QualifiedExpressionResolver qualifiedExpressionResolver,
@NotNull JetImportsFactory importsFactory,
boolean inRootPackage
) {
@NotNull JetScope rootScope = JetModuleUtil.getSubpackagesOfRootScope(module);
Importer importer = new Importer();
if (lookupMode == LookupMode.EVERYTHING) {
fileScope.clearImports();
}
for (ImportPath defaultImportPath : module.getDefaultImports()) {
TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create(
trace, "transient trace to resolve default imports"); //not to trace errors of default imports
JetImportDirective defaultImportDirective = importsFactory.createImportDirective(defaultImportPath);
qualifiedExpressionResolver.processImportReference(defaultImportDirective, rootScope, fileScope, importer,
temporaryTrace, lookupMode);
}
Map<JetImportDirective, Collection<? extends DeclarationDescriptor>> resolvedDirectives = Maps.newHashMap();
JetScope rootScopeForFile = JetModuleUtil.getImportsResolutionScope(module, inRootPackage);
for (JetImportDirective importDirective : importDirectives) {
Collection<? extends DeclarationDescriptor> descriptors =
qualifiedExpressionResolver.processImportReference(importDirective, rootScopeForFile, fileScope, importer,
trace, lookupMode);
if (!descriptors.isEmpty()) {
resolvedDirectives.put(importDirective, descriptors);
}
if (lookupMode != LookupMode.ONLY_CLASSES_AND_PACKAGES) {
checkPlatformTypesMappedToKotlin(module, trace, importDirective, descriptors);
}
}
importer.doImport(fileScope);
if (lookupMode == LookupMode.EVERYTHING) {
for (JetImportDirective importDirective : importDirectives) {
reportConflictingImport(importDirective, fileScope, resolvedDirectives.get(importDirective), trace);
}
}
}
public static void checkPlatformTypesMappedToKotlin(
@NotNull ModuleDescriptor module,