diff --git a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerBasic.java b/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerBasic.java deleted file mode 100644 index f04e5723546..00000000000 --- a/compiler/frontend/src/org/jetbrains/kotlin/di/InjectorForTopDownAnalyzerBasic.java +++ /dev/null @@ -1,299 +0,0 @@ -/* - * Copyright 2010-2015 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.kotlin.di; - -import com.intellij.openapi.project.Project; -import org.jetbrains.kotlin.context.GlobalContext; -import org.jetbrains.kotlin.storage.StorageManager; -import org.jetbrains.kotlin.resolve.BindingTrace; -import org.jetbrains.kotlin.descriptors.ModuleDescriptor; -import org.jetbrains.kotlin.builtins.KotlinBuiltIns; -import org.jetbrains.kotlin.platform.PlatformToKotlinClassMap; -import org.jetbrains.kotlin.resolve.TopDownAnalyzer; -import org.jetbrains.kotlin.resolve.MutablePackageFragmentProvider; -import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider; -import org.jetbrains.kotlin.types.DynamicTypesSettings; -import org.jetbrains.kotlin.resolve.BodyResolver; -import org.jetbrains.kotlin.resolve.AnnotationResolver; -import org.jetbrains.kotlin.resolve.calls.CallResolver; -import org.jetbrains.kotlin.resolve.calls.ArgumentTypeResolver; -import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices; -import org.jetbrains.kotlin.types.expressions.ExpressionTypingComponents; -import org.jetbrains.kotlin.types.expressions.ControlStructureTypingUtils; -import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils; -import org.jetbrains.kotlin.types.expressions.ForLoopConventionsChecker; -import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer; -import org.jetbrains.kotlin.resolve.DescriptorResolver; -import org.jetbrains.kotlin.resolve.DelegatedPropertyResolver; -import org.jetbrains.kotlin.resolve.TypeResolver; -import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver; -import org.jetbrains.kotlin.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider; -import org.jetbrains.kotlin.context.LazinessToken; -import org.jetbrains.kotlin.types.reflect.ReflectionTypes; -import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver; -import org.jetbrains.kotlin.resolve.PartialBodyResolveProvider; -import org.jetbrains.kotlin.resolve.calls.CallCompleter; -import org.jetbrains.kotlin.resolve.calls.CandidateResolver; -import org.jetbrains.kotlin.resolve.calls.tasks.TaskPrioritizer; -import org.jetbrains.kotlin.resolve.ControlFlowAnalyzer; -import org.jetbrains.kotlin.resolve.DeclarationsChecker; -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.TypeHierarchyResolver; -import org.jetbrains.kotlin.resolve.ScriptHeaderResolver; -import org.jetbrains.kotlin.resolve.varianceChecker.VarianceChecker; -import org.jetbrains.annotations.NotNull; -import javax.annotation.PreDestroy; - -/* This file is generated by org.jetbrains.kotlin.generators.injectors.InjectorsPackage. DO NOT EDIT! */ -@SuppressWarnings("all") -public class InjectorForTopDownAnalyzerBasic { - - private final Project project; - private final GlobalContext globalContext; - private final StorageManager storageManager; - private final BindingTrace bindingTrace; - private final ModuleDescriptor moduleDescriptor; - private final KotlinBuiltIns kotlinBuiltIns; - private final PlatformToKotlinClassMap platformToKotlinClassMap; - private final TopDownAnalyzer topDownAnalyzer; - private final MutablePackageFragmentProvider mutablePackageFragmentProvider; - private final AdditionalCheckerProvider additionalCheckerProvider; - private final DynamicTypesSettings dynamicTypesSettings; - private final BodyResolver bodyResolver; - private final AnnotationResolver annotationResolver; - private final CallResolver callResolver; - private final ArgumentTypeResolver argumentTypeResolver; - private final ExpressionTypingServices expressionTypingServices; - private final ExpressionTypingComponents expressionTypingComponents; - private final ControlStructureTypingUtils controlStructureTypingUtils; - private final ExpressionTypingUtils expressionTypingUtils; - private final ForLoopConventionsChecker forLoopConventionsChecker; - private final LocalClassifierAnalyzer localClassifierAnalyzer; - private final DescriptorResolver descriptorResolver; - private final DelegatedPropertyResolver delegatedPropertyResolver; - private final TypeResolver typeResolver; - private final QualifiedExpressionResolver qualifiedExpressionResolver; - private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider; - private final LazinessToken lazinessToken; - private final ReflectionTypes reflectionTypes; - private final CallExpressionResolver callExpressionResolver; - private final PartialBodyResolveProvider partialBodyResolveProvider; - private final CallCompleter callCompleter; - private final CandidateResolver candidateResolver; - private final TaskPrioritizer taskPrioritizer; - private final ControlFlowAnalyzer controlFlowAnalyzer; - private final DeclarationsChecker declarationsChecker; - private final ModifiersChecker modifiersChecker; - 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 TypeHierarchyResolver typeHierarchyResolver; - private final ScriptHeaderResolver scriptHeaderResolver; - private final VarianceChecker varianceChecker; - - public InjectorForTopDownAnalyzerBasic( - @NotNull Project project, - @NotNull GlobalContext globalContext, - @NotNull BindingTrace bindingTrace, - @NotNull ModuleDescriptor moduleDescriptor, - @NotNull AdditionalCheckerProvider additionalCheckerProvider, - @NotNull DynamicTypesSettings dynamicTypesSettings - ) { - this.project = project; - this.globalContext = globalContext; - this.storageManager = globalContext.getStorageManager(); - this.bindingTrace = bindingTrace; - this.moduleDescriptor = moduleDescriptor; - this.kotlinBuiltIns = moduleDescriptor.getBuiltIns(); - this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap(); - this.topDownAnalyzer = new TopDownAnalyzer(); - this.mutablePackageFragmentProvider = new MutablePackageFragmentProvider(getModuleDescriptor()); - this.additionalCheckerProvider = additionalCheckerProvider; - this.dynamicTypesSettings = dynamicTypesSettings; - this.bodyResolver = new BodyResolver(); - this.annotationResolver = new AnnotationResolver(); - this.callResolver = new CallResolver(); - this.argumentTypeResolver = new ArgumentTypeResolver(); - this.expressionTypingComponents = new ExpressionTypingComponents(); - this.expressionTypingServices = new ExpressionTypingServices(expressionTypingComponents); - this.controlStructureTypingUtils = new ControlStructureTypingUtils(expressionTypingServices); - this.expressionTypingUtils = new ExpressionTypingUtils(expressionTypingServices, callResolver, kotlinBuiltIns); - this.forLoopConventionsChecker = new ForLoopConventionsChecker(); - this.descriptorResolver = new DescriptorResolver(); - this.qualifiedExpressionResolver = new QualifiedExpressionResolver(); - this.flexibleTypeCapabilitiesProvider = new FlexibleTypeCapabilitiesProvider(); - this.lazinessToken = new LazinessToken(); - this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, getModuleDescriptor(), flexibleTypeCapabilitiesProvider, storageManager, lazinessToken, dynamicTypesSettings); - this.localClassifierAnalyzer = new LocalClassifierAnalyzer(descriptorResolver, typeResolver, annotationResolver); - this.delegatedPropertyResolver = new DelegatedPropertyResolver(); - this.reflectionTypes = new ReflectionTypes(getModuleDescriptor()); - this.callExpressionResolver = new CallExpressionResolver(); - this.partialBodyResolveProvider = new PartialBodyResolveProvider(); - this.candidateResolver = new CandidateResolver(); - this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver); - this.taskPrioritizer = new TaskPrioritizer(storageManager); - this.controlFlowAnalyzer = new ControlFlowAnalyzer(); - this.declarationsChecker = new DeclarationsChecker(); - this.modifiersChecker = new ModifiersChecker(bindingTrace, additionalCheckerProvider); - 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.typeHierarchyResolver = new TypeHierarchyResolver(); - this.scriptHeaderResolver = new ScriptHeaderResolver(); - this.varianceChecker = new VarianceChecker(bindingTrace); - - this.topDownAnalyzer.setBodyResolver(bodyResolver); - this.topDownAnalyzer.setDeclarationResolver(declarationResolver); - this.topDownAnalyzer.setModuleDescriptor(moduleDescriptor); - this.topDownAnalyzer.setOverloadResolver(overloadResolver); - this.topDownAnalyzer.setOverrideResolver(overrideResolver); - this.topDownAnalyzer.setPackageFragmentProvider(mutablePackageFragmentProvider); - this.topDownAnalyzer.setTypeHierarchyResolver(typeHierarchyResolver); - this.topDownAnalyzer.setVarianceChecker(varianceChecker); - - bodyResolver.setAnnotationResolver(annotationResolver); - bodyResolver.setCallResolver(callResolver); - bodyResolver.setControlFlowAnalyzer(controlFlowAnalyzer); - bodyResolver.setDeclarationsChecker(declarationsChecker); - bodyResolver.setDelegatedPropertyResolver(delegatedPropertyResolver); - bodyResolver.setExpressionTypingServices(expressionTypingServices); - bodyResolver.setFunctionAnalyzerExtension(functionAnalyzerExtension); - bodyResolver.setScriptBodyResolverResolver(scriptBodyResolver); - bodyResolver.setTrace(bindingTrace); - - annotationResolver.setCallResolver(callResolver); - annotationResolver.setStorageManager(storageManager); - annotationResolver.setTypeResolver(typeResolver); - - callResolver.setArgumentTypeResolver(argumentTypeResolver); - callResolver.setCallCompleter(callCompleter); - callResolver.setCandidateResolver(candidateResolver); - callResolver.setExpressionTypingServices(expressionTypingServices); - callResolver.setTaskPrioritizer(taskPrioritizer); - callResolver.setTypeResolver(typeResolver); - - argumentTypeResolver.setBuiltIns(kotlinBuiltIns); - argumentTypeResolver.setExpressionTypingServices(expressionTypingServices); - argumentTypeResolver.setTypeResolver(typeResolver); - - expressionTypingServices.setAnnotationResolver(annotationResolver); - expressionTypingServices.setBuiltIns(kotlinBuiltIns); - expressionTypingServices.setCallExpressionResolver(callExpressionResolver); - expressionTypingServices.setCallResolver(callResolver); - expressionTypingServices.setDescriptorResolver(descriptorResolver); - expressionTypingServices.setPartialBodyResolveProvider(partialBodyResolveProvider); - expressionTypingServices.setProject(project); - expressionTypingServices.setTypeResolver(typeResolver); - - expressionTypingComponents.setAdditionalCheckerProvider(additionalCheckerProvider); - expressionTypingComponents.setBuiltIns(kotlinBuiltIns); - expressionTypingComponents.setCallResolver(callResolver); - expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils); - expressionTypingComponents.setDynamicTypesSettings(dynamicTypesSettings); - expressionTypingComponents.setExpressionTypingServices(expressionTypingServices); - expressionTypingComponents.setExpressionTypingUtils(expressionTypingUtils); - expressionTypingComponents.setForLoopConventionsChecker(forLoopConventionsChecker); - expressionTypingComponents.setGlobalContext(globalContext); - expressionTypingComponents.setLocalClassifierAnalyzer(localClassifierAnalyzer); - expressionTypingComponents.setPlatformToKotlinClassMap(platformToKotlinClassMap); - expressionTypingComponents.setReflectionTypes(reflectionTypes); - - forLoopConventionsChecker.setBuiltIns(kotlinBuiltIns); - forLoopConventionsChecker.setExpressionTypingServices(expressionTypingServices); - forLoopConventionsChecker.setExpressionTypingUtils(expressionTypingUtils); - forLoopConventionsChecker.setProject(project); - - descriptorResolver.setAnnotationResolver(annotationResolver); - descriptorResolver.setBuiltIns(kotlinBuiltIns); - descriptorResolver.setDelegatedPropertyResolver(delegatedPropertyResolver); - descriptorResolver.setExpressionTypingServices(expressionTypingServices); - descriptorResolver.setStorageManager(storageManager); - descriptorResolver.setTypeResolver(typeResolver); - - delegatedPropertyResolver.setBuiltIns(kotlinBuiltIns); - delegatedPropertyResolver.setCallResolver(callResolver); - delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices); - - callExpressionResolver.setExpressionTypingServices(expressionTypingServices); - - candidateResolver.setArgumentTypeResolver(argumentTypeResolver); - - controlFlowAnalyzer.setTrace(bindingTrace); - - declarationsChecker.setDescriptorResolver(descriptorResolver); - declarationsChecker.setModifiersChecker(modifiersChecker); - declarationsChecker.setTrace(bindingTrace); - - functionAnalyzerExtension.setTrace(bindingTrace); - - 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); - - typeHierarchyResolver.setDescriptorResolver(descriptorResolver); - typeHierarchyResolver.setImportsResolver(importsResolver); - typeHierarchyResolver.setPackageFragmentProvider(mutablePackageFragmentProvider); - typeHierarchyResolver.setScriptHeaderResolver(scriptHeaderResolver); - typeHierarchyResolver.setTrace(bindingTrace); - - scriptHeaderResolver.setPackageFragmentProvider(mutablePackageFragmentProvider); - scriptHeaderResolver.setTrace(bindingTrace); - - } - - @PreDestroy - public void destroy() { - } - - public ModuleDescriptor getModuleDescriptor() { - return this.moduleDescriptor; - } - - public TopDownAnalyzer getTopDownAnalyzer() { - return this.topDownAnalyzer; - } - -} diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/TopDownAnalyzer.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/TopDownAnalyzer.java deleted file mode 100644 index aa0fe0fd4eb..00000000000 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/TopDownAnalyzer.java +++ /dev/null @@ -1,179 +0,0 @@ -/* - * Copyright 2010-2015 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.kotlin.resolve; - -import com.google.common.collect.Sets; -import com.intellij.psi.PsiElement; -import kotlin.KotlinPackage; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.kotlin.descriptors.ClassDescriptorWithResolutionScopes; -import org.jetbrains.kotlin.descriptors.ModuleDescriptor; -import org.jetbrains.kotlin.descriptors.PackageFragmentProvider; -import org.jetbrains.kotlin.descriptors.impl.*; -import org.jetbrains.kotlin.name.FqName; -import org.jetbrains.kotlin.psi.JetFile; -import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo; -import org.jetbrains.kotlin.resolve.scopes.JetScope; -import org.jetbrains.kotlin.resolve.scopes.WritableScope; -import org.jetbrains.kotlin.resolve.varianceChecker.VarianceChecker; - -import javax.inject.Inject; -import java.util.Arrays; -import java.util.Collection; -import java.util.List; -import java.util.Set; - -@Deprecated -public class TopDownAnalyzer { - - private DeclarationResolver declarationResolver; - private TypeHierarchyResolver typeHierarchyResolver; - private OverrideResolver overrideResolver; - private VarianceChecker varianceChecker; - private OverloadResolver overloadResolver; - private ModuleDescriptor moduleDescriptor; - private MutablePackageFragmentProvider packageFragmentProvider; - private BodyResolver bodyResolver; - - public TopDownAnalyzer() { - } - - @Inject - public void setDeclarationResolver(@NotNull DeclarationResolver declarationResolver) { - this.declarationResolver = declarationResolver; - } - - @Inject - public void setTypeHierarchyResolver(@NotNull TypeHierarchyResolver typeHierarchyResolver) { - this.typeHierarchyResolver = typeHierarchyResolver; - } - - @Inject - public void setOverrideResolver(@NotNull OverrideResolver overrideResolver) { - this.overrideResolver = overrideResolver; - } - - @Inject - public void setVarianceChecker(@NotNull VarianceChecker varianceChecker) { - this.varianceChecker = varianceChecker; - } - - @Inject - public void setOverloadResolver(@NotNull OverloadResolver overloadResolver) { - this.overloadResolver = overloadResolver; - } - - @Inject - public void setModuleDescriptor(@NotNull ModuleDescriptor moduleDescriptor) { - this.moduleDescriptor = moduleDescriptor; - } - - @Inject - public void setPackageFragmentProvider(@NotNull MutablePackageFragmentProvider packageFragmentProvider) { - this.packageFragmentProvider = packageFragmentProvider; - } - - @Inject - public void setBodyResolver(@NotNull BodyResolver bodyResolver) { - this.bodyResolver = bodyResolver; - } - - public void doProcess( - @NotNull TopDownAnalysisContext c, - @NotNull JetScope outerScope, - @NotNull PackageLikeBuilder owner, - @NotNull Collection declarations - ) { -// c.enableDebugOutput(); - c.debug("Enter"); - - typeHierarchyResolver.process(c, outerScope, owner, declarations); - declarationResolver.process(c); - overrideResolver.process(c); - varianceChecker.process(c); - lockScopes(c); - - overloadResolver.process(c); - - if (!c.getTopDownAnalysisParameters().isAnalyzingBootstrapLibrary()) { - bodyResolver.resolveBodies(c); - } - - c.debug("Exit"); - //noinspection UseOfSystemOutOrSystemErr - c.printDebugOutput(System.out); - } - - private void lockScopes(@NotNull TopDownAnalysisContext c) { - for (ClassDescriptorWithResolutionScopes mutableClassDescriptor : c.getDeclaredClasses().values()) { - ((MutableClassDescriptor) mutableClassDescriptor).lockScopes(); - } - - // SCRIPT: extra code for scripts - Set scriptFqNames = Sets.newHashSet(); - for (JetFile file : c.getFileScopes().keySet()) { - if (file.isScript()) { - scriptFqNames.add(file.getPackageFqName()); - } - } - for (MutablePackageFragmentDescriptor fragment : packageFragmentProvider.getAllFragments()) { - // todo: this is hack in favor of REPL - if (!scriptFqNames.contains(fragment.getFqName())) { - fragment.getMemberScope().changeLockLevel(WritableScope.LockLevel.READING); - } - } - } - - @NotNull - public TopDownAnalysisContext analyzeFiles( - @NotNull TopDownAnalysisParameters topDownAnalysisParameters, - @NotNull Collection files, - @NotNull PackageFragmentProvider... additionalProviders - ) { - return analyzeFiles(topDownAnalysisParameters, files, Arrays.asList(additionalProviders)); - } - - @NotNull - public TopDownAnalysisContext analyzeFiles( - @NotNull TopDownAnalysisParameters topDownAnalysisParameters, - @NotNull Collection files, - @NotNull List additionalProviders - ) { - //noinspection deprecation - assert !topDownAnalysisParameters.isLazy() : "Lazy resolve must be disabled for this method"; - - TopDownAnalysisContext c = new TopDownAnalysisContext(topDownAnalysisParameters, DataFlowInfo.EMPTY); - CompositePackageFragmentProvider provider = - new CompositePackageFragmentProvider(KotlinPackage.plus(Arrays.asList(packageFragmentProvider), additionalProviders)); - - ((ModuleDescriptorImpl) moduleDescriptor).initialize(provider); - - // dummy builder is used because "root" is module descriptor, - // packages added to module explicitly in - doProcess(c, JetModuleUtil.getSubpackagesOfRootScope(moduleDescriptor), new PackageLikeBuilderDummy(), files); - - return c; - } - - - @NotNull - public MutablePackageFragmentProvider getPackageFragmentProvider() { - return packageFragmentProvider; - } -} - - diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeHierarchyResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeHierarchyResolver.java deleted file mode 100644 index c737e03f601..00000000000 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeHierarchyResolver.java +++ /dev/null @@ -1,505 +0,0 @@ -/* - * Copyright 2010-2015 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.kotlin.resolve; - -import com.intellij.psi.PsiElement; -import com.intellij.psi.PsiNameIdentifierOwner; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.kotlin.descriptors.*; -import org.jetbrains.kotlin.descriptors.impl.ConstructorDescriptorImpl; -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.name.Name; -import org.jetbrains.kotlin.name.SpecialNames; -import org.jetbrains.kotlin.psi.*; -import org.jetbrains.kotlin.resolve.scopes.ChainedScope; -import org.jetbrains.kotlin.resolve.scopes.JetScope; -import org.jetbrains.kotlin.resolve.scopes.WritableScope; -import org.jetbrains.kotlin.resolve.scopes.WriteThroughScope; -import org.jetbrains.kotlin.types.JetType; -import org.jetbrains.kotlin.utils.DFS; - -import javax.inject.Inject; -import java.util.*; - -import static org.jetbrains.kotlin.diagnostics.Errors.*; -import static org.jetbrains.kotlin.name.SpecialNames.getClassObjectName; -import static org.jetbrains.kotlin.resolve.BindingContext.FQNAME_TO_CLASS_DESCRIPTOR; -import static org.jetbrains.kotlin.resolve.BindingContext.TYPE; -import static org.jetbrains.kotlin.resolve.DescriptorUtils.isEnumEntry; -import static org.jetbrains.kotlin.resolve.DescriptorUtils.isObject; -import static org.jetbrains.kotlin.resolve.ModifiersChecker.getDefaultClassVisibility; -import static org.jetbrains.kotlin.resolve.ModifiersChecker.resolveVisibilityFromModifiers; -import static org.jetbrains.kotlin.resolve.source.SourcePackage.toSourceElement; - -public class TypeHierarchyResolver { - private static final DFS.Neighbors CLASS_INHERITANCE_EDGES = new DFS.Neighbors() { - @NotNull - @Override - public Iterable getNeighbors(ClassDescriptor current) { - List result = new ArrayList(); - for (JetType supertype : current.getDefaultType().getConstructor().getSupertypes()) { - DeclarationDescriptor descriptor = supertype.getConstructor().getDeclarationDescriptor(); - if (descriptor instanceof ClassDescriptor) { - result.add((ClassDescriptor) descriptor); - } - } - DeclarationDescriptor container = current.getContainingDeclaration(); - if (container instanceof ClassDescriptor) { - result.add((ClassDescriptor) container); - } - return result; - } - }; - - @NotNull - private ImportsResolver importsResolver; - @NotNull - private DescriptorResolver descriptorResolver; - @NotNull - private ScriptHeaderResolver scriptHeaderResolver; - @NotNull - private MutablePackageFragmentProvider packageFragmentProvider; - @NotNull - private BindingTrace trace; - - @Inject - public void setImportsResolver(@NotNull ImportsResolver importsResolver) { - this.importsResolver = importsResolver; - } - - @Inject - public void setDescriptorResolver(@NotNull DescriptorResolver descriptorResolver) { - this.descriptorResolver = descriptorResolver; - } - - // SCRIPT: inject script header resolver - @Inject - public void setScriptHeaderResolver(@NotNull ScriptHeaderResolver scriptHeaderResolver) { - this.scriptHeaderResolver = scriptHeaderResolver; - } - - @Inject - public void setPackageFragmentProvider(@NotNull MutablePackageFragmentProvider packageFragmentProvider) { - this.packageFragmentProvider = packageFragmentProvider; - } - - @Inject - public void setTrace(@NotNull BindingTrace trace) { - this.trace = trace; - } - - public void process( - @NotNull TopDownAnalysisContext c, - @NotNull JetScope outerScope, - @NotNull PackageLikeBuilder owner, - @NotNull Collection declarations - ) { - - { - // TODO: Very temp code - main goal is to remove recursion from collectPackageFragmentsAndClassifiers - Queue forDeferredResolve = new LinkedList(); - forDeferredResolve.addAll(collectPackageFragmentsAndClassifiers(c, outerScope, owner, declarations)); - - while (!forDeferredResolve.isEmpty()) { - JetDeclarationContainer declarationContainer = forDeferredResolve.poll(); - assert declarationContainer != null; - - DeclarationDescriptor descriptorForDeferredResolve = c.forDeferredResolver.get(declarationContainer); - JetScope scope = c.normalScope.get(declarationContainer); - - // Even more temp code - if (descriptorForDeferredResolve instanceof MutableClassDescriptor) { - forDeferredResolve.addAll( - collectPackageFragmentsAndClassifiers( - c, - scope, - ((MutableClassDescriptor) descriptorForDeferredResolve).getBuilder(), - declarationContainer.getDeclarations())); - } - else if (descriptorForDeferredResolve instanceof MutablePackageFragmentDescriptor) { - forDeferredResolve.addAll( - collectPackageFragmentsAndClassifiers( - c, - scope, - ((MutablePackageFragmentDescriptor) descriptorForDeferredResolve).getBuilder(), - declarationContainer.getDeclarations())); - } - else { - assert false; - } - } - } - - importsResolver.processTypeImports(c); - - createTypeConstructors(c); // create type constructors for classes and generic parameters, supertypes are not filled in - resolveTypesInClassHeaders(c); // Generic bounds and types in supertype lists (no expressions or constructor resolution) - - c.setClassesTopologicalOrder(topologicallySortClassesAndObjects(c)); - - // Detect and disconnect all loops in the hierarchy - detectAndDisconnectLoops(c); - } - - @NotNull - private Collection collectPackageFragmentsAndClassifiers( - @NotNull TopDownAnalysisContext c, - @NotNull JetScope outerScope, - @NotNull PackageLikeBuilder owner, - @NotNull Iterable declarations - ) { - Collection forDeferredResolve = new ArrayList(); - - ClassifierCollector collector = new ClassifierCollector(c, outerScope, owner, forDeferredResolve); - - for (PsiElement declaration : declarations) { - declaration.accept(collector); - } - - return forDeferredResolve; - } - - - @NotNull - private static ClassKind getClassKind(@NotNull JetClass jetClass) { - if (jetClass.isTrait()) return ClassKind.TRAIT; - if (jetClass.isAnnotation()) return ClassKind.ANNOTATION_CLASS; - if (jetClass.isEnum()) return ClassKind.ENUM_CLASS; - return ClassKind.CLASS; - } - - private void createTypeConstructors(@NotNull TopDownAnalysisContext c) { - for (Map.Entry entry : c.getDeclaredClasses().entrySet()) { - JetClassOrObject classOrObject = entry.getKey(); - MutableClassDescriptor descriptor = (MutableClassDescriptor) entry.getValue(); - if (classOrObject instanceof JetClass) { - descriptorResolver.resolveMutableClassDescriptor( - c.getTopDownAnalysisParameters(), - (JetClass) classOrObject, descriptor, trace); - } - else if (classOrObject instanceof JetObjectDeclaration) { - descriptor.setModality(Modality.FINAL); - descriptor.setVisibility(resolveVisibilityFromModifiers(classOrObject, getDefaultClassVisibility(descriptor))); - descriptor.setTypeParameterDescriptors(Collections.emptyList()); - } - - descriptor.createTypeConstructor(); - - ClassKind kind = descriptor.getKind(); - if (kind == ClassKind.ENUM_ENTRY || kind == ClassKind.OBJECT) { - MutableClassDescriptor classObject = descriptor.getClassObjectDescriptor(); - assert classObject != null : "Enum entries and named objects should have class objects: " + classOrObject.getText(); - - // This is a clever hack: each enum entry and object declaration (i.e. singleton) has a synthetic class object. - // We make this class object inherit from the singleton here, thus allowing to use the singleton's class object where - // the instance of the singleton is applicable. Effectively all members of the singleton would be present in its class - // object as fake overrides, so you can access them via standard class object notation: ObjectName.memberName() - classObject.setSupertypes(Collections.singleton(descriptor.getDefaultType())); - - classObject.createTypeConstructor(); - } - } - } - - private void resolveTypesInClassHeaders(@NotNull TopDownAnalysisContext c) { - for (Map.Entry entry : c.getDeclaredClasses().entrySet()) { - JetClassOrObject classOrObject = entry.getKey(); - if (classOrObject instanceof JetClass) { - ClassDescriptorWithResolutionScopes descriptor = entry.getValue(); - //noinspection unchecked - descriptorResolver.resolveGenericBounds((JetClass) classOrObject, descriptor, descriptor.getScopeForClassHeaderResolution(), - (List) descriptor.getTypeConstructor().getParameters(), trace); - } - } - - for (Map.Entry entry : c.getDeclaredClasses().entrySet()) { - descriptorResolver.resolveSupertypesForMutableClassDescriptor(entry.getKey(), (MutableClassDescriptor) entry.getValue(), trace); - } - } - - @NotNull - @SuppressWarnings("unchecked") - private static List topologicallySortClassesAndObjects(@NotNull TopDownAnalysisContext c) { - Collection sourceClasses = (Collection) c.getAllClasses(); - List allClassesOrdered = DFS.topologicalOrder(sourceClasses, CLASS_INHERITANCE_EDGES); - allClassesOrdered.retainAll(sourceClasses); - return (List) allClassesOrdered; - } - - private void detectAndDisconnectLoops(@NotNull TopDownAnalysisContext c) { - List tasks = new ArrayList(); - for (final MutableClassDescriptor klass : c.getClassesTopologicalOrder()) { - for (final JetType supertype : klass.getSupertypes()) { - ClassifierDescriptor supertypeDescriptor = supertype.getConstructor().getDeclarationDescriptor(); - if (supertypeDescriptor instanceof ClassDescriptor) { - ClassDescriptor superclass = (ClassDescriptor) supertypeDescriptor; - if (isReachable(superclass, klass, new HashSet())) { - tasks.add(new Runnable() { - @Override - public void run() { - klass.getSupertypes().remove(supertype); - } - }); - reportCyclicInheritanceHierarchyError(trace, klass, superclass); - } - } - } - } - - for (Runnable task : tasks) { - task.run(); - } - } - - // TODO: use DFS and copy to LazyClassTypeConstructor.isReachable - private static boolean isReachable( - @NotNull ClassDescriptor from, - @NotNull MutableClassDescriptor to, - @NotNull Set visited - ) { - if (!visited.add(from)) return false; - for (ClassDescriptor superclass : CLASS_INHERITANCE_EDGES.getNeighbors(from)) { - if (superclass == to || isReachable(superclass, to, visited)) return true; - } - return false; - } - - public static void reportCyclicInheritanceHierarchyError( - @NotNull BindingTrace trace, - @NotNull ClassDescriptor classDescriptor, - @NotNull ClassDescriptor superclass - ) { - PsiElement psiElement = DescriptorToSourceUtils.classDescriptorToDeclaration(classDescriptor); - - PsiElement elementToMark = null; - if (psiElement instanceof JetClassOrObject) { - JetClassOrObject classOrObject = (JetClassOrObject) psiElement; - for (JetDelegationSpecifier delegationSpecifier : classOrObject.getDelegationSpecifiers()) { - JetTypeReference typeReference = delegationSpecifier.getTypeReference(); - if (typeReference == null) continue; - JetType supertype = trace.get(TYPE, typeReference); - if (supertype != null && supertype.getConstructor() == superclass.getTypeConstructor()) { - elementToMark = typeReference; - } - } - } - if (elementToMark == null && psiElement instanceof PsiNameIdentifierOwner) { - PsiNameIdentifierOwner namedElement = (PsiNameIdentifierOwner) psiElement; - PsiElement nameIdentifier = namedElement.getNameIdentifier(); - if (nameIdentifier != null) { - elementToMark = nameIdentifier; - } - } - if (elementToMark != null) { - trace.report(CYCLIC_INHERITANCE_HIERARCHY.on(elementToMark)); - } - } - - private class ClassifierCollector extends JetVisitorVoid { - private final TopDownAnalysisContext c; - private final JetScope outerScope; - private final PackageLikeBuilder owner; - private final Collection forDeferredResolve; - - public ClassifierCollector( - @NotNull TopDownAnalysisContext c, - @NotNull JetScope outerScope, - @NotNull PackageLikeBuilder owner, - @NotNull Collection forDeferredResolve - ) { - this.c = c; - this.outerScope = outerScope; - this.owner = owner; - this.forDeferredResolve = forDeferredResolve; - } - - @Override - public void visitJetFile(@NotNull JetFile file) { - MutablePackageFragmentDescriptor packageFragment = getOrCreatePackageFragmentForFile(file); - c.getPackageFragments().put(file, packageFragment); - c.addFile(file); - - PackageViewDescriptor packageView = packageFragment.getContainingDeclaration().getPackage(packageFragment.getFqName()); - ChainedScope rootPlusPackageScope = new ChainedScope(packageView, "Root scope for " + file, packageView.getMemberScope(), outerScope); - WriteThroughScope packageScope = new WriteThroughScope(rootPlusPackageScope, packageFragment.getMemberScope(), - new TraceBasedRedeclarationHandler(trace), "package in file " + file.getName()); - packageScope.changeLockLevel(WritableScope.LockLevel.BOTH); - c.getFileScopes().put(file, packageScope); - - if (file.isScript()) { - // SCRIPT: process script hierarchy - scriptHeaderResolver.processScriptHierarchy(c, file.getScript(), packageScope); - } - - prepareForDeferredCall(packageScope, packageFragment, file); - } - - @Override - public void visitClass(@NotNull JetClass klass) { - MutableClassDescriptor mutableClassDescriptor = createClassDescriptorForClass(klass, owner.getOwnerForChildren()); - - owner.addClassifierDescriptor(mutableClassDescriptor); - } - - @Override - public void visitObjectDeclaration(@NotNull JetObjectDeclaration declaration) { - if (declaration.isObjectLiteral()) { - createClassDescriptorForSingleton(declaration, SpecialNames.NO_NAME_PROVIDED, ClassKind.CLASS); - return; - } - - MutableClassDescriptor descriptor = - createClassDescriptorForSingleton(declaration, JetPsiUtil.safeName(declaration.getName()), ClassKind.OBJECT); - - owner.addClassifierDescriptor(descriptor); - trace.record(FQNAME_TO_CLASS_DESCRIPTOR, JetNamedDeclarationUtil.getUnsafeFQName(declaration), descriptor); - - descriptor.getBuilder().setClassObjectDescriptor(createSyntheticClassObjectForSingleton(descriptor)); - } - - @Override - public void visitEnumEntry(@NotNull JetEnumEntry declaration) { - MutableClassDescriptor descriptor = - createClassDescriptorForSingleton(declaration, JetPsiUtil.safeName(declaration.getName()), ClassKind.ENUM_ENTRY); - - owner.addClassifierDescriptor(descriptor); - - descriptor.getBuilder().setClassObjectDescriptor(createSyntheticClassObjectForSingleton(descriptor)); - } - - @Override - public void visitTypedef(@NotNull JetTypedef typedef) { - trace.report(UNSUPPORTED.on(typedef, "TypeHierarchyResolver")); - } - - @Override - public void visitClassObject(@NotNull JetClassObject classObject) { - JetObjectDeclaration objectDeclaration = classObject.getObjectDeclaration(); - - DeclarationDescriptor container = owner.getOwnerForChildren(); - - MutableClassDescriptor classObjectDescriptor = - createClassDescriptorForSingleton(objectDeclaration, getClassObjectName(container.getName()), ClassKind.CLASS_OBJECT); - - PackageLikeBuilder.ClassObjectStatus status = - isEnumEntry(container) || isObject(container) || c.getTopDownAnalysisParameters().isDeclaredLocally() ? - PackageLikeBuilder.ClassObjectStatus.NOT_ALLOWED : - owner.setClassObjectDescriptor(classObjectDescriptor); - - switch (status) { - case DUPLICATE: - trace.report(MANY_CLASS_OBJECTS.on(classObject)); - break; - case NOT_ALLOWED: - trace.report(CLASS_OBJECT_NOT_ALLOWED.on(classObject)); - break; - case OK: - // Everything is OK so no errors to trace. - break; - } - } - - @NotNull - private MutablePackageFragmentDescriptor getOrCreatePackageFragmentForFile(@NotNull JetFile file) { - JetPackageDirective packageDirective = file.getPackageDirective(); - assert packageDirective != null : "scripts are not supported"; - - MutablePackageFragmentDescriptor fragment = packageFragmentProvider.getOrCreateFragment(packageDirective.getFqName()); - - ModuleDescriptor module = packageFragmentProvider.getModule(); - DescriptorResolver.resolvePackageHeader(packageDirective, module, trace); - DescriptorResolver.registerFileInPackage(trace, file); - trace.record(BindingContext.FILE_TO_PACKAGE_FRAGMENT, file, fragment); - - return fragment; - } - - - @NotNull - private MutableClassDescriptor createSyntheticClassObjectForSingleton(@NotNull ClassDescriptor classDescriptor) { - MutableClassDescriptor classObject = - new MutableClassDescriptor(classDescriptor, outerScope, ClassKind.CLASS_OBJECT, false, - getClassObjectName(classDescriptor.getName()), SourceElement.NO_SOURCE); - - classObject.setModality(Modality.FINAL); - classObject.setVisibility(DescriptorUtils.getSyntheticClassObjectVisibility()); - classObject.setTypeParameterDescriptors(Collections.emptyList()); - createPrimaryConstructorForObject(null, classObject); - return classObject; - } - - @NotNull - private MutableClassDescriptor createClassDescriptorForClass( - @NotNull JetClass klass, - @NotNull DeclarationDescriptor containingDeclaration - ) { - MutableClassDescriptor descriptor = new MutableClassDescriptor( - containingDeclaration, outerScope, getClassKind(klass), klass.isInner(), JetPsiUtil.safeName(klass.getName()), - toSourceElement(klass) - ); - c.getDeclaredClasses().put(klass, descriptor); - trace.record(FQNAME_TO_CLASS_DESCRIPTOR, JetNamedDeclarationUtil.getUnsafeFQName(klass), descriptor); - - prepareForDeferredCall(descriptor.getScopeForMemberDeclarationResolution(), descriptor, klass); - - return descriptor; - } - - @NotNull - private MutableClassDescriptor createClassDescriptorForSingleton( - @NotNull JetClassOrObject declaration, - @NotNull Name name, - @NotNull ClassKind kind - ) { - MutableClassDescriptor descriptor = new MutableClassDescriptor(owner.getOwnerForChildren(), outerScope, kind, false, name, - toSourceElement(declaration)); - - prepareForDeferredCall(descriptor.getScopeForMemberDeclarationResolution(), descriptor, declaration); - - createPrimaryConstructorForObject(declaration, descriptor); - trace.record(BindingContext.CLASS, declaration, descriptor); - - c.getDeclaredClasses().put(declaration, descriptor); - - return descriptor; - } - - @NotNull - private ConstructorDescriptorImpl createPrimaryConstructorForObject( - @Nullable JetClassOrObject object, - @NotNull MutableClassDescriptor mutableClassDescriptor - ) { - ConstructorDescriptorImpl constructorDescriptor = DescriptorResolver - .createAndRecordPrimaryConstructorForObject(object, mutableClassDescriptor, trace); - mutableClassDescriptor.setPrimaryConstructor(constructorDescriptor); - return constructorDescriptor; - } - - private void prepareForDeferredCall( - @NotNull JetScope outerScope, - @NotNull DeclarationDescriptor descriptorForDeferredResolve, - @NotNull JetDeclarationContainer container - ) { - forDeferredResolve.add(container); - c.normalScope.put(container, outerScope); - c.forDeferredResolver.put(container, descriptorForDeferredResolve); - } - } -} diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java index 5de3dd27506..8fc2ef84c9b 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java @@ -19,6 +19,8 @@ package org.jetbrains.kotlin.resolve.lazy.descriptors; import com.google.common.base.Predicate; import com.google.common.collect.Collections2; import com.google.common.collect.Lists; +import com.intellij.psi.PsiElement; +import com.intellij.psi.PsiNameIdentifierOwner; import kotlin.Function0; import kotlin.Function1; import kotlin.KotlinPackage; @@ -34,10 +36,7 @@ import org.jetbrains.kotlin.descriptors.annotations.Annotations; import org.jetbrains.kotlin.descriptors.impl.ClassDescriptorBase; import org.jetbrains.kotlin.name.Name; import org.jetbrains.kotlin.psi.*; -import org.jetbrains.kotlin.resolve.BindingContext; -import org.jetbrains.kotlin.resolve.DescriptorUtils; -import org.jetbrains.kotlin.resolve.ModifiersChecker; -import org.jetbrains.kotlin.resolve.TypeHierarchyResolver; +import org.jetbrains.kotlin.resolve.*; import org.jetbrains.kotlin.resolve.lazy.ForceResolveUtil; import org.jetbrains.kotlin.resolve.lazy.LazyEntity; import org.jetbrains.kotlin.resolve.lazy.data.JetClassInfoUtil; @@ -57,8 +56,10 @@ import org.jetbrains.kotlin.types.TypeUtils; import java.util.*; import static org.jetbrains.kotlin.diagnostics.Errors.CLASS_OBJECT_NOT_ALLOWED; +import static org.jetbrains.kotlin.diagnostics.Errors.CYCLIC_INHERITANCE_HIERARCHY; import static org.jetbrains.kotlin.diagnostics.Errors.TYPE_PARAMETERS_IN_ENUM; import static org.jetbrains.kotlin.name.SpecialNames.getClassObjectName; +import static org.jetbrains.kotlin.resolve.BindingContext.TYPE; import static org.jetbrains.kotlin.resolve.DescriptorUtils.isSyntheticClassObject; import static org.jetbrains.kotlin.resolve.ModifiersChecker.*; import static org.jetbrains.kotlin.resolve.source.SourcePackage.toSourceElement; @@ -620,13 +621,43 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes ClassifierDescriptor supertypeDescriptor = supertype.getConstructor().getDeclarationDescriptor(); if (supertypeDescriptor instanceof ClassDescriptor) { ClassDescriptor superclass = (ClassDescriptor) supertypeDescriptor; - TypeHierarchyResolver.reportCyclicInheritanceHierarchyError(c.getTrace(), LazyClassDescriptor.this, - superclass); + reportCyclicInheritanceHierarchyError(c.getTrace(), LazyClassDescriptor.this, superclass); } } } } + private void reportCyclicInheritanceHierarchyError( + @NotNull BindingTrace trace, + @NotNull ClassDescriptor classDescriptor, + @NotNull ClassDescriptor superclass + ) { + PsiElement psiElement = DescriptorToSourceUtils.classDescriptorToDeclaration(classDescriptor); + + PsiElement elementToMark = null; + if (psiElement instanceof JetClassOrObject) { + JetClassOrObject classOrObject = (JetClassOrObject) psiElement; + for (JetDelegationSpecifier delegationSpecifier : classOrObject.getDelegationSpecifiers()) { + JetTypeReference typeReference = delegationSpecifier.getTypeReference(); + if (typeReference == null) continue; + JetType supertype = trace.get(TYPE, typeReference); + if (supertype != null && supertype.getConstructor() == superclass.getTypeConstructor()) { + elementToMark = typeReference; + } + } + } + if (elementToMark == null && psiElement instanceof PsiNameIdentifierOwner) { + PsiNameIdentifierOwner namedElement = (PsiNameIdentifierOwner) psiElement; + PsiElement nameIdentifier = namedElement.getNameIdentifier(); + if (nameIdentifier != null) { + elementToMark = nameIdentifier; + } + } + if (elementToMark != null) { + trace.report(CYCLIC_INHERITANCE_HIERARCHY.on(elementToMark)); + } + } + private boolean isReachable(TypeConstructor from, TypeConstructor to, Set visited) { if (!visited.add(from)) return false; for (JetType supertype : getNeighbors(from)) { diff --git a/generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt b/generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt index bb729a88b1d..ed1a1ce18f0 100644 --- a/generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt +++ b/generators/src/org/jetbrains/kotlin/generators/injectors/GenerateInjectors.kt @@ -76,7 +76,6 @@ private val DI_DEFAULT_PACKAGE = "org.jetbrains.kotlin.di" public fun createInjectorGenerators(): List = listOf( - generatorForTopDownAnalyzerBasic(), generatorForLazyTopDownAnalyzerBasic(), generatorForLazyLocalClassifierAnalyzer(), generatorForTopDownAnalyzerForJvm(), @@ -91,21 +90,6 @@ public fun createInjectorGenerators(): List = generatorForReplWithJava() ) -private fun generatorForTopDownAnalyzerBasic() = - generator("compiler/frontend/src", DI_DEFAULT_PACKAGE, "InjectorForTopDownAnalyzerBasic") { - parameter() - parameter(useAsContext = true) - parameter() - publicParameter(useAsContext = true) - - publicField() - - field() - - parameter() - parameter() - } - private fun generatorForLazyTopDownAnalyzerBasic() = generator("compiler/frontend/src", DI_DEFAULT_PACKAGE, "InjectorForLazyTopDownAnalyzerBasic") { commonForResolveSessionBased()