Unused code removed from DeclarationResolver

compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForReplWithJava.java

@@ -77,7 +77,6 @@ import org.jetbrains.kotlin.resolve.DeclarationsChecker;
 import org.jetbrains.kotlin.resolve.ModifiersChecker;
 import org.jetbrains.kotlin.resolve.FunctionAnalyzerExtension;
 import org.jetbrains.kotlin.resolve.DeclarationResolver;
-import org.jetbrains.kotlin.resolve.ImportsResolver;
 import org.jetbrains.kotlin.resolve.OverloadResolver;
 import org.jetbrains.kotlin.resolve.OverrideResolver;
 import org.jetbrains.kotlin.resolve.varianceChecker.VarianceChecker;
@@ -154,7 +153,6 @@ public class InjectorForReplWithJava {
     private final ModifiersChecker modifiersChecker;
     private final FunctionAnalyzerExtension functionAnalyzerExtension;
     private final DeclarationResolver declarationResolver;
-    private final ImportsResolver importsResolver;
     private final OverloadResolver overloadResolver;
     private final OverrideResolver overrideResolver;
     private final VarianceChecker varianceChecker;
@@ -239,7 +237,6 @@ public class InjectorForReplWithJava {
         this.modifiersChecker = new ModifiersChecker(bindingTrace, kotlinJvmCheckerProvider);
         this.functionAnalyzerExtension = new FunctionAnalyzerExtension();
         this.declarationResolver = new DeclarationResolver();
-        this.importsResolver = new ImportsResolver();
         this.overloadResolver = new OverloadResolver();
         this.overrideResolver = new OverrideResolver();
         this.varianceChecker = new VarianceChecker(bindingTrace);
@@ -377,15 +374,8 @@ public class InjectorForReplWithJava {
         functionAnalyzerExtension.setTrace(bindingTrace);
 
         declarationResolver.setAnnotationResolver(annotationResolver);
-        declarationResolver.setDescriptorResolver(descriptorResolver);
-        declarationResolver.setImportsResolver(importsResolver);
         declarationResolver.setTrace(bindingTrace);
 
-        importsResolver.setImportsFactory(jetImportsFactory);
-        importsResolver.setModuleDescriptor(module);
-        importsResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
-        importsResolver.setTrace(bindingTrace);
-
         overloadResolver.setTrace(bindingTrace);
 
         overrideResolver.setTrace(bindingTrace);

compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJvm.java

@@ -77,7 +77,6 @@ import org.jetbrains.kotlin.resolve.DeclarationsChecker;
 import org.jetbrains.kotlin.resolve.ModifiersChecker;
 import org.jetbrains.kotlin.resolve.FunctionAnalyzerExtension;
 import org.jetbrains.kotlin.resolve.DeclarationResolver;
-import org.jetbrains.kotlin.resolve.ImportsResolver;
 import org.jetbrains.kotlin.resolve.OverloadResolver;
 import org.jetbrains.kotlin.resolve.OverrideResolver;
 import org.jetbrains.kotlin.resolve.varianceChecker.VarianceChecker;
@@ -154,7 +153,6 @@ public class InjectorForTopDownAnalyzerForJvm {
     private final ModifiersChecker modifiersChecker;
     private final FunctionAnalyzerExtension functionAnalyzerExtension;
     private final DeclarationResolver declarationResolver;
-    private final ImportsResolver importsResolver;
     private final OverloadResolver overloadResolver;
     private final OverrideResolver overrideResolver;
     private final VarianceChecker varianceChecker;
@@ -238,7 +236,6 @@ public class InjectorForTopDownAnalyzerForJvm {
         this.modifiersChecker = new ModifiersChecker(bindingTrace, kotlinJvmCheckerProvider);
         this.functionAnalyzerExtension = new FunctionAnalyzerExtension();
         this.declarationResolver = new DeclarationResolver();
-        this.importsResolver = new ImportsResolver();
         this.overloadResolver = new OverloadResolver();
         this.overrideResolver = new OverrideResolver();
         this.varianceChecker = new VarianceChecker(bindingTrace);
@@ -376,15 +373,8 @@ public class InjectorForTopDownAnalyzerForJvm {
         functionAnalyzerExtension.setTrace(bindingTrace);
 
         declarationResolver.setAnnotationResolver(annotationResolver);
-        declarationResolver.setDescriptorResolver(descriptorResolver);
-        declarationResolver.setImportsResolver(importsResolver);
         declarationResolver.setTrace(bindingTrace);
 
-        importsResolver.setImportsFactory(jetImportsFactory);
-        importsResolver.setModuleDescriptor(module);
-        importsResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
-        importsResolver.setTrace(bindingTrace);
-
         overloadResolver.setTrace(bindingTrace);
 
         overrideResolver.setTrace(bindingTrace);

compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyBodyResolve.java

@@ -59,8 +59,6 @@ import org.jetbrains.kotlin.resolve.ModifiersChecker;
 import org.jetbrains.kotlin.resolve.FunctionAnalyzerExtension;
 import org.jetbrains.kotlin.resolve.ScriptBodyResolver;
 import org.jetbrains.kotlin.resolve.DeclarationResolver;
-import org.jetbrains.kotlin.resolve.ImportsResolver;
-import org.jetbrains.kotlin.psi.JetImportsFactory;
 import org.jetbrains.kotlin.resolve.OverloadResolver;
 import org.jetbrains.kotlin.resolve.OverrideResolver;
 import org.jetbrains.kotlin.resolve.varianceChecker.VarianceChecker;
@@ -114,8 +112,6 @@ public class InjectorForLazyBodyResolve {
     private final FunctionAnalyzerExtension functionAnalyzerExtension;
     private final ScriptBodyResolver scriptBodyResolver;
     private final DeclarationResolver declarationResolver;
-    private final ImportsResolver importsResolver;
-    private final JetImportsFactory jetImportsFactory;
     private final OverloadResolver overloadResolver;
     private final OverrideResolver overrideResolver;
     private final VarianceChecker varianceChecker;
@@ -171,8 +167,6 @@ public class InjectorForLazyBodyResolve {
         this.functionAnalyzerExtension = new FunctionAnalyzerExtension();
         this.scriptBodyResolver = new ScriptBodyResolver();
         this.declarationResolver = new DeclarationResolver();
-        this.importsResolver = new ImportsResolver();
-        this.jetImportsFactory = new JetImportsFactory();
         this.overloadResolver = new OverloadResolver();
         this.overrideResolver = new OverrideResolver();
         this.varianceChecker = new VarianceChecker(bindingTrace);
@@ -275,17 +269,8 @@ public class InjectorForLazyBodyResolve {
         scriptBodyResolver.setExpressionTypingServices(expressionTypingServices);
 
         declarationResolver.setAnnotationResolver(annotationResolver);
-        declarationResolver.setDescriptorResolver(descriptorResolver);
-        declarationResolver.setImportsResolver(importsResolver);
         declarationResolver.setTrace(bindingTrace);
 
-        importsResolver.setImportsFactory(jetImportsFactory);
-        importsResolver.setModuleDescriptor(moduleDescriptor);
-        importsResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
-        importsResolver.setTrace(bindingTrace);
-
-        jetImportsFactory.setProject(project);
-
         overloadResolver.setTrace(bindingTrace);
 
         overrideResolver.setTrace(bindingTrace);

compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyLocalClassifierAnalyzer.java

@@ -59,8 +59,6 @@ import org.jetbrains.kotlin.resolve.ModifiersChecker;
 import org.jetbrains.kotlin.resolve.FunctionAnalyzerExtension;
 import org.jetbrains.kotlin.resolve.ScriptBodyResolver;
 import org.jetbrains.kotlin.resolve.DeclarationResolver;
-import org.jetbrains.kotlin.resolve.ImportsResolver;
-import org.jetbrains.kotlin.psi.JetImportsFactory;
 import org.jetbrains.kotlin.resolve.OverloadResolver;
 import org.jetbrains.kotlin.resolve.OverrideResolver;
 import org.jetbrains.kotlin.resolve.varianceChecker.VarianceChecker;
@@ -114,8 +112,6 @@ public class InjectorForLazyLocalClassifierAnalyzer {
     private final FunctionAnalyzerExtension functionAnalyzerExtension;
     private final ScriptBodyResolver scriptBodyResolver;
     private final DeclarationResolver declarationResolver;
-    private final ImportsResolver importsResolver;
-    private final JetImportsFactory jetImportsFactory;
     private final OverloadResolver overloadResolver;
     private final OverrideResolver overrideResolver;
     private final VarianceChecker varianceChecker;
@@ -172,8 +168,6 @@ public class InjectorForLazyLocalClassifierAnalyzer {
         this.functionAnalyzerExtension = new FunctionAnalyzerExtension();
         this.scriptBodyResolver = new ScriptBodyResolver();
         this.declarationResolver = new DeclarationResolver();
-        this.importsResolver = new ImportsResolver();
-        this.jetImportsFactory = new JetImportsFactory();
         this.overloadResolver = new OverloadResolver();
         this.overrideResolver = new OverrideResolver();
         this.varianceChecker = new VarianceChecker(bindingTrace);
@@ -273,17 +267,8 @@ public class InjectorForLazyLocalClassifierAnalyzer {
         scriptBodyResolver.setExpressionTypingServices(expressionTypingServices);
 
         declarationResolver.setAnnotationResolver(annotationResolver);
-        declarationResolver.setDescriptorResolver(descriptorResolver);
-        declarationResolver.setImportsResolver(importsResolver);
         declarationResolver.setTrace(bindingTrace);
 
-        importsResolver.setImportsFactory(jetImportsFactory);
-        importsResolver.setModuleDescriptor(module);
-        importsResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
-        importsResolver.setTrace(bindingTrace);
-
-        jetImportsFactory.setProject(project);
-
         overloadResolver.setTrace(bindingTrace);
 
         overrideResolver.setTrace(bindingTrace);

compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyTopDownAnalyzerBasic.java

@@ -62,7 +62,6 @@ import org.jetbrains.kotlin.resolve.DeclarationsChecker;
 import org.jetbrains.kotlin.resolve.ModifiersChecker;
 import org.jetbrains.kotlin.resolve.FunctionAnalyzerExtension;
 import org.jetbrains.kotlin.resolve.DeclarationResolver;
-import org.jetbrains.kotlin.resolve.ImportsResolver;
 import org.jetbrains.kotlin.resolve.OverloadResolver;
 import org.jetbrains.kotlin.resolve.OverrideResolver;
 import org.jetbrains.kotlin.resolve.varianceChecker.VarianceChecker;
@@ -119,7 +118,6 @@ public class InjectorForLazyTopDownAnalyzerBasic {
     private final ModifiersChecker modifiersChecker;
     private final FunctionAnalyzerExtension functionAnalyzerExtension;
     private final DeclarationResolver declarationResolver;
-    private final ImportsResolver importsResolver;
     private final OverloadResolver overloadResolver;
     private final OverrideResolver overrideResolver;
     private final VarianceChecker varianceChecker;
@@ -177,7 +175,6 @@ public class InjectorForLazyTopDownAnalyzerBasic {
         this.modifiersChecker = new ModifiersChecker(bindingTrace, defaultProvider);
         this.functionAnalyzerExtension = new FunctionAnalyzerExtension();
         this.declarationResolver = new DeclarationResolver();
-        this.importsResolver = new ImportsResolver();
         this.overloadResolver = new OverloadResolver();
         this.overrideResolver = new OverrideResolver();
         this.varianceChecker = new VarianceChecker(bindingTrace);
@@ -294,15 +291,8 @@ public class InjectorForLazyTopDownAnalyzerBasic {
         functionAnalyzerExtension.setTrace(bindingTrace);
 
         declarationResolver.setAnnotationResolver(annotationResolver);
-        declarationResolver.setDescriptorResolver(descriptorResolver);
-        declarationResolver.setImportsResolver(importsResolver);
         declarationResolver.setTrace(bindingTrace);
 
-        importsResolver.setImportsFactory(jetImportsFactory);
-        importsResolver.setModuleDescriptor(module);
-        importsResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
-        importsResolver.setTrace(bindingTrace);
-
         overloadResolver.setTrace(bindingTrace);
 
         overrideResolver.setTrace(bindingTrace);

compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationResolver.java

@@ -16,44 +16,40 @@
 
 package org.jetbrains.kotlin.resolve;
 
-import com.google.common.base.Function;
+import com.google.common.collect.HashMultimap;
-import com.google.common.base.Predicate;
+import com.google.common.collect.Lists;
-import com.google.common.collect.*;
+import com.google.common.collect.Multimap;
+import com.google.common.collect.Sets;
 import com.intellij.openapi.util.Pair;
 import com.intellij.psi.PsiElement;
 import com.intellij.util.containers.ContainerUtil;
 import kotlin.Function1;
 import kotlin.KotlinPackage;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.descriptors.*;
-import org.jetbrains.kotlin.descriptors.impl.MutableClassDescriptor;
-import org.jetbrains.kotlin.descriptors.impl.MutablePackageFragmentDescriptor;
-import org.jetbrains.kotlin.descriptors.impl.PackageLikeBuilder;
 import org.jetbrains.kotlin.diagnostics.Errors;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.Name;
-import org.jetbrains.kotlin.psi.*;
+import org.jetbrains.kotlin.psi.JetElement;
-import org.jetbrains.kotlin.renderer.DescriptorRenderer;
+import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.psi.JetNamedDeclaration;
+import org.jetbrains.kotlin.psi.JetPackageDirective;
 import org.jetbrains.kotlin.resolve.lazy.FileScopeProvider;
 import org.jetbrains.kotlin.resolve.lazy.TopLevelDescriptorProvider;
 import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyPackageDescriptor;
-import org.jetbrains.kotlin.resolve.resolveUtil.ResolveUtilPackage;
 import org.jetbrains.kotlin.resolve.scopes.JetScope;
-import org.jetbrains.kotlin.resolve.scopes.WritableScope;
 import org.jetbrains.kotlin.utils.UtilsPackage;
 
 import javax.inject.Inject;
-import java.util.*;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
 
 import static org.jetbrains.kotlin.diagnostics.Errors.REDECLARATION;
-import static org.jetbrains.kotlin.resolve.ScriptHeaderResolver.resolveScriptDeclarations;
 
 public class DeclarationResolver {
     private AnnotationResolver annotationResolver;
-    private ImportsResolver importsResolver;
-    private DescriptorResolver descriptorResolver;
     private BindingTrace trace;
 
 
@@ -62,40 +58,12 @@ public class DeclarationResolver {
         this.annotationResolver = annotationResolver;
     }
 
-    @Inject
-    public void setImportsResolver(@NotNull ImportsResolver importsResolver) {
-        this.importsResolver = importsResolver;
-    }
-
-    @Inject
-    public void setDescriptorResolver(@NotNull DescriptorResolver descriptorResolver) {
-        this.descriptorResolver = descriptorResolver;
-    }
-
     @Inject
     public void setTrace(@NotNull BindingTrace trace) {
         this.trace = trace;
     }
 
 
-    public void process(@NotNull TopDownAnalysisContext c) {
-        resolveAnnotationConstructors(c);
-        resolveConstructorHeaders(c);
-        resolveAnnotationStubsOnClassesAndConstructors(c);
-        resolveFunctionAndPropertyHeaders(c);
-        resolveDanglingAnnotationsInClasses(c);
-        resolveAnnotationsOnFiles(c.getFileScopes());
-
-        // SCRIPT: Resolve script declarations
-        resolveScriptDeclarations(c);
-
-        createFunctionsForDataClasses(c);
-        importsResolver.processMembersImports(c);
-        ResolveUtilPackage.checkTraitRequirements(c.getDeclaredClasses(), trace);
-        checkRedeclarationsInPackages(c);
-        checkRedeclarationsInInnerClassNames(c);
-    }
-
     public void resolveAnnotationsOnFiles(@NotNull TopDownAnalysisContext c, @NotNull final FileScopeProvider scopeProvider) {
         Map<JetFile, JetScope> file2scope = UtilsPackage.keysToMap(c.getFiles(), new Function1<JetFile, JetScope>() {
             @Override
@@ -116,140 +84,6 @@ public class DeclarationResolver {
         }
     }
 
-    private void resolveAnnotationConstructors(@NotNull TopDownAnalysisContext c) {
-        for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry : c.getDeclaredClasses().entrySet()) {
-            JetClassOrObject classOrObject = entry.getKey();
-            MutableClassDescriptor classDescriptor = (MutableClassDescriptor) entry.getValue();
-
-            if (classOrObject instanceof JetClass && DescriptorUtils.isAnnotationClass(classDescriptor)) {
-                processPrimaryConstructor(c, classDescriptor, (JetClass) classOrObject);
-            }
-        }
-    }
-
-    private void resolveConstructorHeaders(@NotNull TopDownAnalysisContext c) {
-        for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry : c.getDeclaredClasses().entrySet()) {
-            JetClassOrObject classOrObject = entry.getKey();
-            MutableClassDescriptor classDescriptor = (MutableClassDescriptor) entry.getValue();
-
-            if (classOrObject instanceof JetClass && !DescriptorUtils.isAnnotationClass(classDescriptor)) {
-                processPrimaryConstructor(c, classDescriptor, (JetClass) classOrObject);
-            }
-        }
-    }
-
-    private void resolveAnnotationStubsOnClassesAndConstructors(@NotNull TopDownAnalysisContext c) {
-        for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry : c.getDeclaredClasses().entrySet()) {
-            JetModifierList modifierList = entry.getKey().getModifierList();
-            if (modifierList != null) {
-                MutableClassDescriptor descriptor = (MutableClassDescriptor) entry.getValue();
-                descriptor.addAnnotations(annotationResolver.resolveAnnotationsWithoutArguments(
-                        descriptor.getScopeForClassHeaderResolution(), modifierList, trace));
-            }
-        }
-    }
-
-    private void resolveFunctionAndPropertyHeaders(@NotNull TopDownAnalysisContext c) {
-        for (Map.Entry<JetFile, WritableScope> entry : c.getFileScopes().entrySet()) {
-            JetFile file = entry.getKey();
-            WritableScope fileScope = entry.getValue();
-            PackageLikeBuilder packageBuilder = c.getPackageFragments().get(file).getBuilder();
-
-            resolveFunctionAndPropertyHeaders(c, file.getDeclarations(), fileScope, fileScope, fileScope, packageBuilder);
-        }
-        for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry : c.getDeclaredClasses().entrySet()) {
-            JetClassOrObject classOrObject = entry.getKey();
-            MutableClassDescriptor classDescriptor = (MutableClassDescriptor) entry.getValue();
-
-            resolveFunctionAndPropertyHeaders(
-                    c,
-                    classOrObject.getDeclarations(), classDescriptor.getScopeForMemberDeclarationResolution(),
-                    classDescriptor.getScopeForInitializerResolution(), classDescriptor.getScopeForMemberDeclarationResolution(),
-                    classDescriptor.getBuilder());
-        }
-
-        // TODO : Extensions
-    }
-
-    private void resolveFunctionAndPropertyHeaders(
-            @NotNull final TopDownAnalysisContext c,
-            @NotNull List<JetDeclaration> declarations,
-            @NotNull final JetScope scopeForFunctions,
-            @NotNull final JetScope scopeForPropertyInitializers,
-            @NotNull final JetScope scopeForPropertyAccessors,
-            @NotNull final PackageLikeBuilder packageLike)
-    {
-        for (JetDeclaration declaration : declarations) {
-            declaration.accept(new JetVisitorVoid() {
-                @Override
-                public void visitNamedFunction(@NotNull JetNamedFunction function) {
-                    SimpleFunctionDescriptor functionDescriptor = descriptorResolver.resolveFunctionDescriptor(
-                            packageLike.getOwnerForChildren(),
-                            scopeForFunctions,
-                            function,
-                            trace,
-                            c.getOuterDataFlowInfo()
-                    );
-                    packageLike.addFunctionDescriptor(functionDescriptor);
-                    c.getFunctions().put(function, functionDescriptor);
-                    c.registerDeclaringScope(function, scopeForFunctions);
-                }
-
-                @Override
-                public void visitProperty(@NotNull JetProperty property) {
-                    PropertyDescriptor propertyDescriptor = descriptorResolver.resolvePropertyDescriptor(
-                            packageLike.getOwnerForChildren(),
-                            scopeForPropertyInitializers,
-                            property,
-                            trace,
-                            c.getOuterDataFlowInfo()
-                    );
-                    packageLike.addPropertyDescriptor(propertyDescriptor);
-                    c.getProperties().put(property, propertyDescriptor);
-                    c.registerDeclaringScope(property, scopeForPropertyInitializers);
-                    JetPropertyAccessor getter = property.getGetter();
-                    if (getter != null) {
-                        c.registerDeclaringScope(getter, scopeForPropertyAccessors);
-                    }
-                    JetPropertyAccessor setter = property.getSetter();
-                    if (setter != null) {
-                        c.registerDeclaringScope(setter, scopeForPropertyAccessors);
-                    }
-                }
-            });
-        }
-    }
-
-    private void resolveDanglingAnnotationsInClasses(TopDownAnalysisContext c) {
-        for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry : c.getDeclaredClasses().entrySet()) {
-            JetClassBody body = entry.getKey().getBody();
-            if (body != null) {
-                annotationResolver.resolveAnnotationsWithArguments(
-                        entry.getValue().getScopeForMemberDeclarationResolution(),
-                        body.getDanglingAnnotations(),
-                        trace
-                );
-            }
-        }
-    }
-
-    private void createFunctionsForDataClasses(@NotNull TopDownAnalysisContext c) {
-        for (Map.Entry<JetClassOrObject, ClassDescriptorWithResolutionScopes> entry : c.getDeclaredClasses().entrySet()) {
-            JetClassOrObject klass = entry.getKey();
-            MutableClassDescriptor classDescriptor = (MutableClassDescriptor) entry.getValue();
-
-            if (klass instanceof JetClass && KotlinBuiltIns.isData(classDescriptor)) {
-                List<ValueParameterDescriptor> parameters =
-                        klass.hasPrimaryConstructor() ?
-                        getConstructorOfDataClass(classDescriptor).getValueParameters() :
-                        Collections.<ValueParameterDescriptor>emptyList();
-
-                createComponentFunctions(classDescriptor, parameters);
-                createCopyFunction(classDescriptor, parameters);
-            }
-        }
-    }
-
     @NotNull
     public static ConstructorDescriptor getConstructorOfDataClass(@NotNull ClassDescriptor classDescriptor) {
         Collection<ConstructorDescriptor> constructors = classDescriptor.getConstructors();
@@ -257,124 +91,6 @@ public class DeclarationResolver {
         return constructors.iterator().next();
     }
 
-    private void createComponentFunctions(@NotNull MutableClassDescriptor classDescriptor, List<ValueParameterDescriptor> parameters) {
-        int parameterIndex = 0;
-        for (ValueParameterDescriptor parameter : parameters) {
-            if (!parameter.getType().isError()) {
-                PropertyDescriptor property = trace.get(BindingContext.VALUE_PARAMETER_AS_PROPERTY, parameter);
-                if (property != null) {
-                    ++parameterIndex;
-
-                    SimpleFunctionDescriptor functionDescriptor =
-                            DescriptorResolver.createComponentFunctionDescriptor(parameterIndex, property, parameter, classDescriptor, trace);
-
-                    classDescriptor.getBuilder().addFunctionDescriptor(functionDescriptor);
-                }
-            }
-        }
-    }
-
-    private void createCopyFunction(@NotNull MutableClassDescriptor classDescriptor, List<ValueParameterDescriptor> parameters) {
-        SimpleFunctionDescriptor functionDescriptor = DescriptorResolver.createCopyFunctionDescriptor(
-                parameters, classDescriptor, trace);
-
-        classDescriptor.getBuilder().addFunctionDescriptor(functionDescriptor);
-    }
-
-    private void processPrimaryConstructor(
-            @NotNull TopDownAnalysisContext c,
-            @NotNull MutableClassDescriptor classDescriptor,
-            @NotNull JetClass klass
-    ) {
-        // TODO : not all the parameters are real properties
-        JetScope memberScope = classDescriptor.getScopeForClassHeaderResolution();
-        ConstructorDescriptor constructorDescriptor = descriptorResolver.resolvePrimaryConstructorDescriptor(memberScope, classDescriptor, klass, trace);
-        if (constructorDescriptor != null) {
-            List<ValueParameterDescriptor> valueParameterDescriptors = constructorDescriptor.getValueParameters();
-            List<JetParameter> primaryConstructorParameters = klass.getPrimaryConstructorParameters();
-            assert valueParameterDescriptors.size() == primaryConstructorParameters.size();
-            List<ValueParameterDescriptor> notProperties = new ArrayList<ValueParameterDescriptor>();
-            for (ValueParameterDescriptor valueParameterDescriptor : valueParameterDescriptors) {
-                JetParameter parameter = primaryConstructorParameters.get(valueParameterDescriptor.getIndex());
-                if (parameter.hasValOrVarNode()) {
-                    PropertyDescriptor propertyDescriptor = descriptorResolver.resolvePrimaryConstructorParameterToAProperty(
-                            classDescriptor,
-                            valueParameterDescriptor,
-                            memberScope,
-                            parameter, trace
-                    );
-                    classDescriptor.getBuilder().addPropertyDescriptor(propertyDescriptor);
-                    c.getPrimaryConstructorParameterProperties().put(parameter, propertyDescriptor);
-                }
-                else {
-                    notProperties.add(valueParameterDescriptor);
-                }
-            }
-
-            if (classDescriptor.getKind() != ClassKind.TRAIT) {
-                classDescriptor.setPrimaryConstructor(constructorDescriptor);
-                classDescriptor.addConstructorParametersToInitializersScope(notProperties);
-            }
-        }
-    }
-
-    private void checkRedeclarationsInPackages(@NotNull TopDownAnalysisContext c) {
-        for (MutablePackageFragmentDescriptor packageFragment : Sets.newHashSet(c.getPackageFragments().values())) {
-            PackageViewDescriptor packageView = packageFragment.getContainingDeclaration().getPackage(packageFragment.getFqName());
-            JetScope packageViewScope = packageView.getMemberScope();
-            Multimap<Name, DeclarationDescriptor> simpleNameDescriptors = packageFragment.getMemberScope().getDeclaredDescriptorsAccessibleBySimpleName();
-            for (Name name : simpleNameDescriptors.keySet()) {
-                // Keep only properties with no receiver
-                Collection<DeclarationDescriptor> descriptors = Collections2.filter(simpleNameDescriptors.get(name), new Predicate<DeclarationDescriptor>() {
-                    @Override
-                    public boolean apply(@Nullable DeclarationDescriptor descriptor) {
-                        if (descriptor instanceof PropertyDescriptor) {
-                            PropertyDescriptor propertyDescriptor = (PropertyDescriptor)descriptor;
-                            return propertyDescriptor.getExtensionReceiverParameter() == null;
-                        }
-                        return true;
-                    }
-                });
-                ContainerUtil.addIfNotNull(descriptors, packageViewScope.getPackage(name));
-
-                if (descriptors.size() > 1) {
-                    for (DeclarationDescriptor declarationDescriptor : descriptors) {
-                        for (PsiElement declaration : getDeclarationsByDescriptor(declarationDescriptor)) {
-                            assert declaration != null : "Null declaration for descriptor: " + declarationDescriptor + " " +
-                                                         (declarationDescriptor != null ? DescriptorRenderer.FQ_NAMES_IN_TYPES.render(declarationDescriptor) : "");
-                            trace.report(REDECLARATION.on(declaration, declarationDescriptor.getName().asString()));
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    @NotNull
-    private Collection<PsiElement> getDeclarationsByDescriptor(@NotNull DeclarationDescriptor declarationDescriptor) {
-        Collection<PsiElement> declarations;
-        if (declarationDescriptor instanceof PackageViewDescriptor) {
-            final PackageViewDescriptor aPackage = (PackageViewDescriptor)declarationDescriptor;
-            Collection<JetFile> files = trace.get(BindingContext.PACKAGE_TO_FILES, aPackage.getFqName());
-
-            if (files == null) {
-                return Collections.emptyList(); // package can be defined out of Kotlin sources, e. g. in library or Java code
-            }
-
-            declarations = Collections2.transform(files, new Function<JetFile, PsiElement>() {
-                @Override
-                public PsiElement apply(@Nullable JetFile file) {
-                    assert file != null : "File is null for aPackage " + aPackage;
-                    return file.getPackageDirective().getNameIdentifier();
-                }
-            });
-        }
-        else {
-            declarations = Collections.singletonList(DescriptorToSourceUtils.descriptorToDeclaration(declarationDescriptor));
-        }
-        return declarations;
-    }
-
     public void checkRedeclarationsInInnerClassNames(@NotNull TopDownAnalysisContext c) {
         for (ClassDescriptorWithResolutionScopes classDescriptor : c.getDeclaredClasses().values()) {
             if (classDescriptor.getKind() == ClassKind.CLASS_OBJECT) {

js/js.frontend/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJs.java

@@ -62,7 +62,6 @@ import org.jetbrains.kotlin.resolve.DeclarationsChecker;
 import org.jetbrains.kotlin.resolve.ModifiersChecker;
 import org.jetbrains.kotlin.resolve.FunctionAnalyzerExtension;
 import org.jetbrains.kotlin.resolve.DeclarationResolver;
-import org.jetbrains.kotlin.resolve.ImportsResolver;
 import org.jetbrains.kotlin.resolve.OverloadResolver;
 import org.jetbrains.kotlin.resolve.OverrideResolver;
 import org.jetbrains.kotlin.resolve.varianceChecker.VarianceChecker;
@@ -119,7 +118,6 @@ public class InjectorForTopDownAnalyzerForJs {
     private final ModifiersChecker modifiersChecker;
     private final FunctionAnalyzerExtension functionAnalyzerExtension;
     private final DeclarationResolver declarationResolver;
-    private final ImportsResolver importsResolver;
     private final OverloadResolver overloadResolver;
     private final OverrideResolver overrideResolver;
     private final VarianceChecker varianceChecker;
@@ -177,7 +175,6 @@ public class InjectorForTopDownAnalyzerForJs {
         this.modifiersChecker = new ModifiersChecker(bindingTrace, kotlinJsCheckerProvider);
         this.functionAnalyzerExtension = new FunctionAnalyzerExtension();
         this.declarationResolver = new DeclarationResolver();
-        this.importsResolver = new ImportsResolver();
         this.overloadResolver = new OverloadResolver();
         this.overrideResolver = new OverrideResolver();
         this.varianceChecker = new VarianceChecker(bindingTrace);
@@ -294,15 +291,8 @@ public class InjectorForTopDownAnalyzerForJs {
         functionAnalyzerExtension.setTrace(bindingTrace);
 
         declarationResolver.setAnnotationResolver(annotationResolver);
-        declarationResolver.setDescriptorResolver(descriptorResolver);
-        declarationResolver.setImportsResolver(importsResolver);
         declarationResolver.setTrace(bindingTrace);
 
-        importsResolver.setImportsFactory(jetImportsFactory);
-        importsResolver.setModuleDescriptor(module);
-        importsResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
-        importsResolver.setTrace(bindingTrace);
-
         overloadResolver.setTrace(bindingTrace);
 
         overrideResolver.setTrace(bindingTrace);