From 828507de78f12fce1bf9d12b9f2f9f2c50856df7 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Fri, 23 Jan 2015 19:12:11 +0300 Subject: [PATCH] Unused code removed from DeclarationResolver --- .../kotlin/di/InjectorForReplWithJava.java | 10 - .../di/InjectorForTopDownAnalyzerForJvm.java | 10 - .../kotlin/di/InjectorForLazyBodyResolve.java | 15 - ...njectorForLazyLocalClassifierAnalyzer.java | 15 - .../InjectorForLazyTopDownAnalyzerBasic.java | 10 - .../kotlin/resolve/DeclarationResolver.java | 308 +----------------- .../di/InjectorForTopDownAnalyzerForJs.java | 10 - 7 files changed, 12 insertions(+), 366 deletions(-) diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForReplWithJava.java b/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForReplWithJava.java index 2e4bc3a9809..8e9d1956c54 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForReplWithJava.java +++ b/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); diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJvm.java b/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJvm.java index 102b95799f9..a064c3af8c1 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJvm.java +++ b/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); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyBodyResolve.java b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyBodyResolve.java index 8f343f4b4e4..4c560818d91 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyBodyResolve.java +++ b/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); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyLocalClassifierAnalyzer.java b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyLocalClassifierAnalyzer.java index b34215d9ec4..b19ed42b6b9 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyLocalClassifierAnalyzer.java +++ b/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); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyTopDownAnalyzerBasic.java b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyTopDownAnalyzerBasic.java index 452c4016f98..b82ffc05af8 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForLazyTopDownAnalyzerBasic.java +++ b/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); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationResolver.java index 0573f3cdcb8..a141e06356b 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationResolver.java +++ b/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.base.Predicate; -import com.google.common.collect.*; +import com.google.common.collect.HashMultimap; +import com.google.common.collect.Lists; +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.renderer.DescriptorRenderer; +import org.jetbrains.kotlin.psi.JetElement; +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 file2scope = UtilsPackage.keysToMap(c.getFiles(), new Function1() { @Override @@ -116,140 +84,6 @@ public class DeclarationResolver { } } - private void resolveAnnotationConstructors(@NotNull TopDownAnalysisContext c) { - for (Map.Entry 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 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 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 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 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 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 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 entry : c.getDeclaredClasses().entrySet()) { - JetClassOrObject klass = entry.getKey(); - MutableClassDescriptor classDescriptor = (MutableClassDescriptor) entry.getValue(); - - if (klass instanceof JetClass && KotlinBuiltIns.isData(classDescriptor)) { - List parameters = - klass.hasPrimaryConstructor() ? - getConstructorOfDataClass(classDescriptor).getValueParameters() : - Collections.emptyList(); - - createComponentFunctions(classDescriptor, parameters); - createCopyFunction(classDescriptor, parameters); - } - } - } - @NotNull public static ConstructorDescriptor getConstructorOfDataClass(@NotNull ClassDescriptor classDescriptor) { Collection constructors = classDescriptor.getConstructors(); @@ -257,124 +91,6 @@ public class DeclarationResolver { return constructors.iterator().next(); } - private void createComponentFunctions(@NotNull MutableClassDescriptor classDescriptor, List 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 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 valueParameterDescriptors = constructorDescriptor.getValueParameters(); - List primaryConstructorParameters = klass.getPrimaryConstructorParameters(); - assert valueParameterDescriptors.size() == primaryConstructorParameters.size(); - List notProperties = new ArrayList(); - 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 simpleNameDescriptors = packageFragment.getMemberScope().getDeclaredDescriptorsAccessibleBySimpleName(); - for (Name name : simpleNameDescriptors.keySet()) { - // Keep only properties with no receiver - Collection descriptors = Collections2.filter(simpleNameDescriptors.get(name), new Predicate() { - @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 getDeclarationsByDescriptor(@NotNull DeclarationDescriptor declarationDescriptor) { - Collection declarations; - if (declarationDescriptor instanceof PackageViewDescriptor) { - final PackageViewDescriptor aPackage = (PackageViewDescriptor)declarationDescriptor; - Collection 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() { - @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) { diff --git a/js/js.frontend/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJs.java b/js/js.frontend/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJs.java index bb8b971cc67..b740df4721e 100644 --- a/js/js.frontend/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerForJs.java +++ b/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);