From 246466bdc50efa4e92d49d585908c6a987c939cf Mon Sep 17 00:00:00 2001 From: "Pavel V. Talanov" Date: Mon, 17 Mar 2014 17:53:30 +0400 Subject: [PATCH] Implement stub based package declaration provider for lazy resolve Implement StubPackageMemberDeclarationProvider Introduce DeclarationProviderFactoryService to provide difference factories in CLI and Plugin When indexing treat top level declarations without name specially so that they can be found in index Implement PluginDeclarationProviderFactoryService which uses file based approach for non indexed files and stub based for others --- .../com/intellij/psi/stubs/annotations.xml | 7 ++ .../cli/jvm/compiler/JetCoreEnvironment.java | 14 ++- .../resolve/java/AnalyzerFacadeForJVM.java | 42 ++++---- .../jetbrains/jet/lang/psi/JetPsiUtil.java | 36 ++++--- .../stubs/elements/JetClassElementType.java | 3 +- .../elements/JetFunctionElementType.java | 12 +-- .../stubs/elements/JetObjectElementType.java | 3 +- .../elements/JetPropertyElementType.java | 8 +- .../resolve/lazy/ResolveSessionUtils.java | 20 ++-- .../AbstractDeclarationProviderFactory.java | 47 +++++++++ .../CliDeclarationProviderFactoryService.java | 34 +++++++ .../declarations/DeclarationProvider.java | 6 ++ .../DeclarationProviderFactoryService.java | 43 ++++++++ .../FileBasedDeclarationProviderFactory.java | 23 +---- ...BasedPackageMemberDeclarationProvider.java | 3 +- .../PackageMemberDeclarationProvider.java | 12 ++- idea/src/META-INF/plugin.xml | 3 + .../plugin/stubindex/JetAllPackagesIndex.java | 2 + .../stubindex/JetFullClassNameIndex.java | 2 + .../stubindex/JetSourceFilterScope.java | 6 +- .../JetTopLevelFunctionsFqnNameIndex.java | 2 + .../JetTopLevelPropertiesFqnNameIndex.java | 2 + .../stubindex/StubIndexServiceImpl.java | 25 +++-- .../AbstractStubDeclarationProvider.java | 42 -------- ...ombinedPackageMemberDeclarationProvider.kt | 40 ++++++++ .../PluginDeclarationProviderFactory.kt | 61 ++++++++++++ ...PluginDeclarationProviderFactoryService.kt | 44 +++++++++ ...ubBasedPackageMemberDeclarationProvider.kt | 99 +++++++++++++++++++ .../StubDeclarationProviderFactory.java | 52 ---------- .../StubPackageMemberDeclarationProvider.java | 99 ------------------- .../stubs/resolve/JetStubResolveTest.java | 16 +-- .../k2js/analyze/AnalyzerFacadeForJS.java | 9 +- 32 files changed, 520 insertions(+), 297 deletions(-) create mode 100644 compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/declarations/AbstractDeclarationProviderFactory.java create mode 100644 compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/declarations/CliDeclarationProviderFactoryService.java create mode 100644 compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/declarations/DeclarationProviderFactoryService.java delete mode 100644 idea/src/org/jetbrains/jet/plugin/stubindex/resolve/AbstractStubDeclarationProvider.java create mode 100644 idea/src/org/jetbrains/jet/plugin/stubindex/resolve/CombinedPackageMemberDeclarationProvider.kt create mode 100644 idea/src/org/jetbrains/jet/plugin/stubindex/resolve/PluginDeclarationProviderFactory.kt create mode 100644 idea/src/org/jetbrains/jet/plugin/stubindex/resolve/PluginDeclarationProviderFactoryService.kt create mode 100644 idea/src/org/jetbrains/jet/plugin/stubindex/resolve/StubBasedPackageMemberDeclarationProvider.kt delete mode 100644 idea/src/org/jetbrains/jet/plugin/stubindex/resolve/StubDeclarationProviderFactory.java delete mode 100644 idea/src/org/jetbrains/jet/plugin/stubindex/resolve/StubPackageMemberDeclarationProvider.java diff --git a/annotations/com/intellij/psi/stubs/annotations.xml b/annotations/com/intellij/psi/stubs/annotations.xml index 77d8576d860..f8578aa6f5c 100644 --- a/annotations/com/intellij/psi/stubs/annotations.xml +++ b/annotations/com/intellij/psi/stubs/annotations.xml @@ -1,4 +1,11 @@ + + + + + + diff --git a/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/JetCoreEnvironment.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/JetCoreEnvironment.java index 7c56aec9da1..2ca4ab293c9 100644 --- a/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/JetCoreEnvironment.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/JetCoreEnvironment.java @@ -57,6 +57,8 @@ import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.java.JetFilesProvider; import org.jetbrains.jet.lang.resolve.kotlin.KotlinBinaryClassCache; import org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinder; +import org.jetbrains.jet.lang.resolve.lazy.declarations.CliDeclarationProviderFactoryService; +import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFactoryService; import org.jetbrains.jet.plugin.JetFileType; import org.jetbrains.jet.utils.PathUtil; @@ -75,7 +77,10 @@ public class JetCoreEnvironment { private static int ourProjectCount = 0; @NotNull - public static JetCoreEnvironment createForProduction(@NotNull Disposable parentDisposable, @NotNull CompilerConfiguration configuration) { + public static JetCoreEnvironment createForProduction( + @NotNull Disposable parentDisposable, + @NotNull CompilerConfiguration configuration + ) { // JPS may run many instances of the compiler in parallel (there's an option for compiling independent modules in parallel in IntelliJ) // All projects share the same ApplicationEnvironment, and when the last project is disposed, the ApplicationEnvironment is disposed as well Disposer.register(parentDisposable, new Disposable() { @@ -88,7 +93,8 @@ public class JetCoreEnvironment { } } }); - JetCoreEnvironment environment = new JetCoreEnvironment(parentDisposable, getOrCreateApplicationEnvironmentForProduction(), configuration); + JetCoreEnvironment environment = + new JetCoreEnvironment(parentDisposable, getOrCreateApplicationEnvironmentForProduction(), configuration); synchronized (APPLICATION_LOCK) { ourProjectCount++; } @@ -146,6 +152,8 @@ public class JetCoreEnvironment { applicationEnvironment.getApplication().registerService(OperationModeProvider.class, new CompilerModeProvider()); applicationEnvironment.getApplication().registerService(KotlinBinaryClassCache.class, new KotlinBinaryClassCache()); + applicationEnvironment.getApplication().registerService(DeclarationProviderFactoryService.class, + new CliDeclarationProviderFactoryService()); return applicationEnvironment; } @@ -185,7 +193,7 @@ public class JetCoreEnvironment { CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), ClsCustomNavigationPolicy.EP_NAME, ClsCustomNavigationPolicy.class); CoreApplicationEnvironment.registerExtensionPoint(Extensions.getRootArea(), ClassFileDecompilers.EP_NAME, - ClassFileDecompilers.Decompiler.class); + ClassFileDecompilers.Decompiler.class); annotationsManager = new CoreExternalAnnotationsManager(project.getComponent(PsiManager.class)); project.registerService(ExternalAnnotationsManager.class, annotationsManager); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java index 4b514569013..4d8fa9b9dfd 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java @@ -37,7 +37,8 @@ import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.*; import org.jetbrains.jet.lang.resolve.java.mapping.JavaToKotlinClassMap; import org.jetbrains.jet.lang.resolve.lazy.ResolveSession; -import org.jetbrains.jet.lang.resolve.lazy.declarations.FileBasedDeclarationProviderFactory; +import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFactory; +import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFactoryService; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; @@ -59,21 +60,24 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade { @Override @NotNull - public AnalyzeExhaust analyzeFiles(@NotNull Project project, + public AnalyzeExhaust analyzeFiles( + @NotNull Project project, @NotNull Collection files, @NotNull List scriptParameters, - @NotNull Predicate filesToAnalyzeCompletely) { + @NotNull Predicate filesToAnalyzeCompletely + ) { return analyzeFilesWithJavaIntegration(project, files, scriptParameters, filesToAnalyzeCompletely, true); } @NotNull @Override - public AnalyzeExhaust analyzeBodiesInFiles(@NotNull Project project, - @NotNull List scriptParameters, - @NotNull Predicate filesForBodiesResolve, - @NotNull BindingTrace headersTraceContext, - @NotNull BodiesResolveContext bodiesResolveContext, - @NotNull ModuleDescriptor module + public AnalyzeExhaust analyzeBodiesInFiles( + @NotNull Project project, + @NotNull List scriptParameters, + @NotNull Predicate filesForBodiesResolve, + @NotNull BindingTrace headersTraceContext, + @NotNull BodiesResolveContext bodiesResolveContext, + @NotNull ModuleDescriptor module ) { return AnalyzerFacadeForEverything.analyzeBodiesInFilesWithJavaIntegration( project, scriptParameters, filesForBodiesResolve, @@ -95,10 +99,8 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade { ) { GlobalContextImpl globalContext = ContextPackage.GlobalContext(); - // TODO: Replace with stub declaration provider - FileBasedDeclarationProviderFactory declarationProviderFactory = new FileBasedDeclarationProviderFactory( - globalContext.getStorageManager(), - files); + DeclarationProviderFactory declarationProviderFactory = + DeclarationProviderFactoryService.createDeclarationProviderFactory(project, globalContext.getStorageManager(), files); InjectorForLazyResolveWithJava resolveWithJava = new InjectorForLazyResolveWithJava( project, @@ -120,7 +122,8 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade { @NotNull public static AnalyzeExhaust analyzeOneFileWithJavaIntegrationAndCheckForErrors( - JetFile file, List scriptParameters) { + JetFile file, List scriptParameters + ) { AnalyzingUtils.checkForSyntacticErrors(file); AnalyzeExhaust analyzeExhaust = analyzeOneFileWithJavaIntegration(file, scriptParameters); @@ -132,7 +135,8 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade { @NotNull public static AnalyzeExhaust analyzeOneFileWithJavaIntegration( - JetFile file, List scriptParameters) { + JetFile file, List scriptParameters + ) { return analyzeFilesWithJavaIntegration(file.getProject(), Collections.singleton(file), scriptParameters, Predicates.alwaysTrue()); } @@ -169,8 +173,12 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade { @NotNull public static AnalyzeExhaust analyzeFilesWithJavaIntegration( - Project project, Collection files, List scriptParameters, Predicate filesToAnalyzeCompletely, - boolean storeContextForBodiesResolve) { + Project project, + Collection files, + List scriptParameters, + Predicate filesToAnalyzeCompletely, + boolean storeContextForBodiesResolve + ) { BindingTraceContext bindingTraceContext = new BindingTraceContext(); return analyzeFilesWithJavaIntegration(project, files, bindingTraceContext, scriptParameters, filesToAnalyzeCompletely, diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java index aec5d03b885..98870b0fd48 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetPsiUtil.java @@ -44,7 +44,10 @@ import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lexer.JetToken; import org.jetbrains.jet.lexer.JetTokens; -import java.util.*; +import java.util.Collection; +import java.util.HashSet; +import java.util.List; +import java.util.Set; public class JetPsiUtil { private JetPsiUtil() { @@ -205,42 +208,47 @@ public class JetPsiUtil { return null; } + FqName parentFqName = getParentFqName(namedDeclaration); + + if (parentFqName == null) { + return null; + } + + return parentFqName.child(name); + } + + @Nullable + public static FqName getParentFqName(@NotNull JetNamedDeclaration namedDeclaration) { PsiElement parent = namedDeclaration.getParent(); if (parent instanceof JetClassBody) { // One nesting to JetClassBody doesn't affect to qualified name parent = parent.getParent(); } - FqName firstPart = null; if (parent instanceof JetFile) { - firstPart = getFQName((JetFile) parent); + return getFQName((JetFile) parent); } else if (parent instanceof JetNamedFunction || parent instanceof JetClass) { - firstPart = getFQName((JetNamedDeclaration) parent); + return getFQName((JetNamedDeclaration) parent); } else if (namedDeclaration instanceof JetParameter) { JetClass constructorClass = getClassIfParameterIsProperty((JetParameter) namedDeclaration); if (constructorClass != null) { - firstPart = getFQName(constructorClass); + return getFQName(constructorClass); } } else if (parent instanceof JetObjectDeclaration) { if (parent.getParent() instanceof JetClassObject) { JetClassOrObject classOrObject = PsiTreeUtil.getParentOfType(parent, JetClassOrObject.class); if (classOrObject != null) { - firstPart = getFQName(classOrObject); + return getFQName(classOrObject); } } else { - firstPart = getFQName((JetNamedDeclaration) parent); + return getFQName((JetNamedDeclaration) parent); } } - - if (firstPart == null) { - return null; - } - - return firstPart.child(name); + return null; } /** @return null iff the tye has syntactic errors */ @@ -811,7 +819,7 @@ public class JetPsiUtil { final List results = Lists.newArrayList(); - ((JetElement) root).accept( + root.accept( new JetVisitorVoid() { @Override public void visitJetElement(@NotNull JetElement element) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/elements/JetClassElementType.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/elements/JetClassElementType.java index 8554370e24d..e14dee57123 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/elements/JetClassElementType.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/elements/JetClassElementType.java @@ -30,6 +30,7 @@ import org.jetbrains.jet.lang.psi.JetPsiUtil; import org.jetbrains.jet.lang.psi.psiUtil.PsiUtilPackage; import org.jetbrains.jet.lang.psi.stubs.PsiJetClassStub; import org.jetbrains.jet.lang.psi.stubs.impl.PsiJetClassStubImpl; +import org.jetbrains.jet.lang.resolve.lazy.ResolveSessionUtils; import org.jetbrains.jet.lang.resolve.name.FqName; import java.io.IOException; @@ -57,7 +58,7 @@ public class JetClassElementType extends JetStubElementType superNames = PsiUtilPackage.getSuperNames(psi); return new PsiJetClassStubImpl( diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/elements/JetFunctionElementType.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/elements/JetFunctionElementType.java index a7719a50d86..8bbd8cf8c06 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/elements/JetFunctionElementType.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/elements/JetFunctionElementType.java @@ -29,6 +29,7 @@ import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.psi.JetNamedFunction; import org.jetbrains.jet.lang.psi.stubs.PsiJetFunctionStub; import org.jetbrains.jet.lang.psi.stubs.impl.PsiJetFunctionStubImpl; +import org.jetbrains.jet.lang.resolve.lazy.ResolveSessionUtils; import org.jetbrains.jet.lang.resolve.name.FqName; import java.io.IOException; @@ -53,10 +54,7 @@ public class JetFunctionElementType extends JetStubElementType superNames = PsiUtilPackage.getSuperNames(psi); return new PsiJetObjectStubImpl( parentStub, diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/elements/JetPropertyElementType.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/elements/JetPropertyElementType.java index 19c0f3b3a7a..94b13426d50 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/elements/JetPropertyElementType.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/stubs/elements/JetPropertyElementType.java @@ -30,6 +30,7 @@ import org.jetbrains.jet.lang.psi.JetProperty; import org.jetbrains.jet.lang.psi.JetTypeReference; import org.jetbrains.jet.lang.psi.stubs.PsiJetPropertyStub; import org.jetbrains.jet.lang.psi.stubs.impl.PsiJetPropertyStubImpl; +import org.jetbrains.jet.lang.resolve.lazy.ResolveSessionUtils; import org.jetbrains.jet.lang.resolve.name.FqName; import java.io.IOException; @@ -53,10 +54,7 @@ public class JetPropertyElementType extends JetStubElementType"); return new PsiJetPropertyStubImpl(parentStub, - psi.getName(), psi.isVar(), psi.isTopLevel(), psi.getFqName(), + psi.getName(), psi.isVar(), psi.isTopLevel(), ResolveSessionUtils.safeFqNameForLazyResolve(psi), typeRef != null ? typeRef.getText() : null, expression != null ? expression.getText() : null); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSessionUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSessionUtils.java index 8cba29557e4..078b4bcd7e6 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSessionUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSessionUtils.java @@ -21,17 +21,18 @@ import com.google.common.base.Predicates; import com.google.common.collect.Lists; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.descriptors.*; -import org.jetbrains.jet.lang.psi.JetNamed; +import org.jetbrains.jet.lang.descriptors.ClassDescriptor; +import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor; +import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor; +import org.jetbrains.jet.lang.psi.JetNamedDeclaration; +import org.jetbrains.jet.lang.psi.JetPsiUtil; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.name.NamePackage; import org.jetbrains.jet.lang.resolve.scopes.JetScope; -import java.util.Arrays; import java.util.Collection; import java.util.Collections; -import java.util.List; public class ResolveSessionUtils { @@ -141,12 +142,19 @@ public class ResolveSessionUtils { } @NotNull - public static Name safeNameForLazyResolve(@NotNull JetNamed named) { - return safeNameForLazyResolve(named.getNameAsName()); + public static Name safeNameForLazyResolve(@NotNull JetNamedDeclaration declaration) { + return safeNameForLazyResolve(declaration.getNameAsName()); } @NotNull public static Name safeNameForLazyResolve(@Nullable Name name) { return name != null ? name : NO_NAME_FOR_LAZY_RESOLVE; } + + @Nullable + public static FqName safeFqNameForLazyResolve(@NotNull JetNamedDeclaration declaration) { + //NOTE: should only create special names for package level declarations, so we can safely rely on real fq name for parent + FqName parentFqName = JetPsiUtil.getParentFqName(declaration); + return parentFqName != null ? parentFqName.child(safeNameForLazyResolve(declaration)) : null; + } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/declarations/AbstractDeclarationProviderFactory.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/declarations/AbstractDeclarationProviderFactory.java new file mode 100644 index 00000000000..0e841295d62 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/declarations/AbstractDeclarationProviderFactory.java @@ -0,0 +1,47 @@ +/* + * Copyright 2010-2014 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.jet.lang.resolve.lazy.declarations; + +import kotlin.Function1; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.lang.resolve.name.FqName; +import org.jetbrains.jet.storage.LockBasedStorageManager; +import org.jetbrains.jet.storage.MemoizedFunctionToNullable; +import org.jetbrains.jet.storage.StorageManager; + +public abstract class AbstractDeclarationProviderFactory implements DeclarationProviderFactory { + private final MemoizedFunctionToNullable packageDeclarationProviders; + + public AbstractDeclarationProviderFactory(@NotNull StorageManager storageManager) { + this.packageDeclarationProviders = + storageManager.createMemoizedFunctionWithNullableValues(new Function1() { + @Override + public PackageMemberDeclarationProvider invoke(FqName fqName) { + return createPackageMemberDeclarationProvider(fqName); + } + }); + } + + @Nullable + protected abstract PackageMemberDeclarationProvider createPackageMemberDeclarationProvider(@NotNull FqName name); + + @Override + public PackageMemberDeclarationProvider getPackageMemberDeclarationProvider(@NotNull FqName packageFqName) { + return packageDeclarationProviders.invoke(packageFqName); + } +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/declarations/CliDeclarationProviderFactoryService.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/declarations/CliDeclarationProviderFactoryService.java new file mode 100644 index 00000000000..18f8655567a --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/declarations/CliDeclarationProviderFactoryService.java @@ -0,0 +1,34 @@ +/* + * Copyright 2010-2014 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.jet.lang.resolve.lazy.declarations; + +import com.intellij.openapi.project.Project; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.psi.JetFile; +import org.jetbrains.jet.storage.StorageManager; + +import java.util.Collection; + +public final class CliDeclarationProviderFactoryService extends DeclarationProviderFactoryService { + @NotNull + @Override + public DeclarationProviderFactory create( + @NotNull Project project, @NotNull StorageManager storageManager, @NotNull Collection files + ) { + return new FileBasedDeclarationProviderFactory(storageManager, files); + } +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/declarations/DeclarationProvider.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/declarations/DeclarationProvider.java index 9894265a02d..9094f884ee9 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/declarations/DeclarationProvider.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/declarations/DeclarationProvider.java @@ -17,6 +17,7 @@ package org.jetbrains.jet.lang.resolve.lazy.declarations; import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.ReadOnly; import org.jetbrains.jet.lang.psi.JetClassOrObject; import org.jetbrains.jet.lang.psi.JetDeclaration; import org.jetbrains.jet.lang.psi.JetNamedFunction; @@ -27,14 +28,19 @@ import java.util.Collection; import java.util.List; public interface DeclarationProvider { + @ReadOnly + @NotNull List getAllDeclarations(); + @ReadOnly @NotNull Collection getFunctionDeclarations(@NotNull Name name); + @ReadOnly @NotNull Collection getPropertyDeclarations(@NotNull Name name); + @ReadOnly @NotNull Collection getClassOrObjectDeclarations(@NotNull Name name); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/declarations/DeclarationProviderFactoryService.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/declarations/DeclarationProviderFactoryService.java new file mode 100644 index 00000000000..e1edc27a241 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/declarations/DeclarationProviderFactoryService.java @@ -0,0 +1,43 @@ +/* + * Copyright 2010-2014 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.jet.lang.resolve.lazy.declarations; + +import com.intellij.openapi.components.ServiceManager; +import com.intellij.openapi.project.Project; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.psi.JetFile; +import org.jetbrains.jet.storage.StorageManager; + +import java.util.Collection; + +public abstract class DeclarationProviderFactoryService { + @NotNull + public abstract DeclarationProviderFactory create( + @NotNull Project project, + @NotNull StorageManager storageManager, + @NotNull Collection files + ); + + @NotNull + public static DeclarationProviderFactory createDeclarationProviderFactory( + @NotNull Project project, + @NotNull StorageManager storageManager, + @NotNull Collection files + ) { + return ServiceManager.getService(DeclarationProviderFactoryService.class).create(project, storageManager, files); + } +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/declarations/FileBasedDeclarationProviderFactory.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/declarations/FileBasedDeclarationProviderFactory.java index 3a1b33cfabe..980eb8fabce 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/declarations/FileBasedDeclarationProviderFactory.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/declarations/FileBasedDeclarationProviderFactory.java @@ -22,7 +22,6 @@ import com.intellij.psi.NavigatablePsiElement; import com.intellij.util.Function; import com.intellij.util.containers.ContainerUtil; import kotlin.Function0; -import kotlin.Function1; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.psi.JetFile; @@ -30,16 +29,15 @@ import org.jetbrains.jet.lang.psi.JetPackageDirective; import org.jetbrains.jet.lang.psi.JetPsiUtil; import org.jetbrains.jet.lang.resolve.lazy.data.JetClassLikeInfo; import org.jetbrains.jet.lang.resolve.name.FqName; -import org.jetbrains.jet.storage.MemoizedFunctionToNullable; +import org.jetbrains.jet.lang.resolve.name.NamePackage; import org.jetbrains.jet.storage.NotNullLazyValue; import org.jetbrains.jet.storage.StorageManager; -import org.jetbrains.jet.lang.resolve.name.NamePackage; import java.util.Collection; import java.util.Collections; import java.util.Set; -public class FileBasedDeclarationProviderFactory implements DeclarationProviderFactory { +public class FileBasedDeclarationProviderFactory extends AbstractDeclarationProviderFactory { private static class Index { private final Multimap filesByPackage = HashMultimap.create(); @@ -49,9 +47,8 @@ public class FileBasedDeclarationProviderFactory implements DeclarationProviderF private final StorageManager storageManager; private final NotNullLazyValue index; - private final MemoizedFunctionToNullable packageDeclarationProviders; - public FileBasedDeclarationProviderFactory(@NotNull StorageManager storageManager, @NotNull final Collection files) { + super(storageManager); this.storageManager = storageManager; this.index = storageManager.createLazyValue(new Function0() { @Override @@ -59,12 +56,6 @@ public class FileBasedDeclarationProviderFactory implements DeclarationProviderF return computeFilesByPackage(files); } }); - this.packageDeclarationProviders = storageManager.createMemoizedFunctionWithNullableValues(new Function1() { - @Override - public PackageMemberDeclarationProvider invoke(FqName fqName) { - return createPackageMemberDeclarationProvider(fqName); - } - }); } @NotNull @@ -124,13 +115,9 @@ public class FileBasedDeclarationProviderFactory implements DeclarationProviderF return resultElements; } - @Override - public PackageMemberDeclarationProvider getPackageMemberDeclarationProvider(@NotNull FqName packageFqName) { - return packageDeclarationProviders.invoke(packageFqName); - } - @Nullable - public PackageMemberDeclarationProvider createPackageMemberDeclarationProvider(@NotNull FqName packageFqName) { + @Override + protected PackageMemberDeclarationProvider createPackageMemberDeclarationProvider(@NotNull FqName packageFqName) { if (isPackageDeclaredExplicitly(packageFqName)) { return new FileBasedPackageMemberDeclarationProvider( storageManager, packageFqName, this, index.invoke().filesByPackage.get(packageFqName)); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/declarations/FileBasedPackageMemberDeclarationProvider.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/declarations/FileBasedPackageMemberDeclarationProvider.java index 5ea3c5966a9..24f5fccb92d 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/declarations/FileBasedPackageMemberDeclarationProvider.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/declarations/FileBasedPackageMemberDeclarationProvider.java @@ -63,6 +63,7 @@ public class FileBasedPackageMemberDeclarationProvider extends AbstractPsiBasedD } } + @NotNull @Override public Collection getAllDeclaredPackages() { return allDeclaredPackages.invoke(); @@ -70,7 +71,7 @@ public class FileBasedPackageMemberDeclarationProvider extends AbstractPsiBasedD @NotNull @Override - public Collection getPackageDeclarations(FqName fqName) { + public Collection getPackageDeclarations(@NotNull FqName fqName) { return factory.getPackageDeclarations(fqName); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/declarations/PackageMemberDeclarationProvider.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/declarations/PackageMemberDeclarationProvider.java index 2f45e503962..6a8423bfbba 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/declarations/PackageMemberDeclarationProvider.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/declarations/PackageMemberDeclarationProvider.java @@ -26,12 +26,16 @@ import java.util.Collection; public interface PackageMemberDeclarationProvider extends DeclarationProvider { + //TODO: method name + @ReadOnly + @NotNull Collection getAllDeclaredPackages(); - @NotNull - Collection getPackageDeclarations(FqName fqName); - - @NotNull @ReadOnly + @NotNull + Collection getPackageDeclarations(@NotNull FqName fqName); + + @ReadOnly + @NotNull Collection getPackageFiles(); } diff --git a/idea/src/META-INF/plugin.xml b/idea/src/META-INF/plugin.xml index 030ead5ad98..f17b456e2a5 100644 --- a/idea/src/META-INF/plugin.xml +++ b/idea/src/META-INF/plugin.xml @@ -108,6 +108,9 @@ + + diff --git a/idea/src/org/jetbrains/jet/plugin/stubindex/JetAllPackagesIndex.java b/idea/src/org/jetbrains/jet/plugin/stubindex/JetAllPackagesIndex.java index 7ba54e6b36b..ae59465ee03 100644 --- a/idea/src/org/jetbrains/jet/plugin/stubindex/JetAllPackagesIndex.java +++ b/idea/src/org/jetbrains/jet/plugin/stubindex/JetAllPackagesIndex.java @@ -36,6 +36,7 @@ public class JetAllPackagesIndex extends StringStubIndexExtension { private static final JetAllPackagesIndex ourInstance = new JetAllPackagesIndex(); + @NotNull public static JetAllPackagesIndex getInstance() { return ourInstance; } @@ -48,6 +49,7 @@ public class JetAllPackagesIndex extends StringStubIndexExtension { return KEY; } + @NotNull @Override public Collection get(String fqName, Project project, @NotNull GlobalSearchScope scope) { return super.get(fqName, project, JetSourceFilterScope.kotlinSourcesAndLibraries(scope)); diff --git a/idea/src/org/jetbrains/jet/plugin/stubindex/JetFullClassNameIndex.java b/idea/src/org/jetbrains/jet/plugin/stubindex/JetFullClassNameIndex.java index 3fc566e7b7c..f7b037e476e 100644 --- a/idea/src/org/jetbrains/jet/plugin/stubindex/JetFullClassNameIndex.java +++ b/idea/src/org/jetbrains/jet/plugin/stubindex/JetFullClassNameIndex.java @@ -30,6 +30,7 @@ public class JetFullClassNameIndex extends StringStubIndexExtension get(String fqName, Project project, @NotNull GlobalSearchScope scope) { return super.get(fqName, project, JetSourceFilterScope.kotlinSourcesAndLibraries(scope)); diff --git a/idea/src/org/jetbrains/jet/plugin/stubindex/JetSourceFilterScope.java b/idea/src/org/jetbrains/jet/plugin/stubindex/JetSourceFilterScope.java index 0cc0e25c97e..500e0c50732 100644 --- a/idea/src/org/jetbrains/jet/plugin/stubindex/JetSourceFilterScope.java +++ b/idea/src/org/jetbrains/jet/plugin/stubindex/JetSourceFilterScope.java @@ -27,11 +27,13 @@ import org.jetbrains.jet.plugin.JetFileType; import org.jetbrains.jet.plugin.JetPluginUtil; public class JetSourceFilterScope extends DelegatingGlobalSearchScope { - public static JetSourceFilterScope kotlinSourcesAndLibraries(@NotNull GlobalSearchScope delegate) { + @NotNull + public static GlobalSearchScope kotlinSourcesAndLibraries(@NotNull GlobalSearchScope delegate) { return new JetSourceFilterScope(delegate, true); } - public static JetSourceFilterScope kotlinSources(@NotNull GlobalSearchScope delegate) { + @NotNull + public static GlobalSearchScope kotlinSources(@NotNull GlobalSearchScope delegate) { return new JetSourceFilterScope(delegate, false); } diff --git a/idea/src/org/jetbrains/jet/plugin/stubindex/JetTopLevelFunctionsFqnNameIndex.java b/idea/src/org/jetbrains/jet/plugin/stubindex/JetTopLevelFunctionsFqnNameIndex.java index 04cc0945467..fa5d8def349 100644 --- a/idea/src/org/jetbrains/jet/plugin/stubindex/JetTopLevelFunctionsFqnNameIndex.java +++ b/idea/src/org/jetbrains/jet/plugin/stubindex/JetTopLevelFunctionsFqnNameIndex.java @@ -33,6 +33,7 @@ public class JetTopLevelFunctionsFqnNameIndex extends StringStubIndexExtension get(String s, Project project, @NotNull GlobalSearchScope scope) { return super.get(s, project, JetSourceFilterScope.kotlinSourcesAndLibraries(scope)); diff --git a/idea/src/org/jetbrains/jet/plugin/stubindex/JetTopLevelPropertiesFqnNameIndex.java b/idea/src/org/jetbrains/jet/plugin/stubindex/JetTopLevelPropertiesFqnNameIndex.java index 831528428de..8c61d52bc09 100644 --- a/idea/src/org/jetbrains/jet/plugin/stubindex/JetTopLevelPropertiesFqnNameIndex.java +++ b/idea/src/org/jetbrains/jet/plugin/stubindex/JetTopLevelPropertiesFqnNameIndex.java @@ -30,6 +30,7 @@ public class JetTopLevelPropertiesFqnNameIndex extends StringStubIndexExtension< private static final JetTopLevelPropertiesFqnNameIndex INSTANCE = new JetTopLevelPropertiesFqnNameIndex(); + @NotNull public static JetTopLevelPropertiesFqnNameIndex getInstance() { return INSTANCE; } @@ -42,6 +43,7 @@ public class JetTopLevelPropertiesFqnNameIndex extends StringStubIndexExtension< return KEY; } + @NotNull @Override public Collection get(String s, Project project, @NotNull GlobalSearchScope scope) { return super.get(s, project, JetSourceFilterScope.kotlinSourcesAndLibraries(scope)); diff --git a/idea/src/org/jetbrains/jet/plugin/stubindex/StubIndexServiceImpl.java b/idea/src/org/jetbrains/jet/plugin/stubindex/StubIndexServiceImpl.java index b988cd0feba..00e26f02b3e 100644 --- a/idea/src/org/jetbrains/jet/plugin/stubindex/StubIndexServiceImpl.java +++ b/idea/src/org/jetbrains/jet/plugin/stubindex/StubIndexServiceImpl.java @@ -120,30 +120,29 @@ public class StubIndexServiceImpl implements StubIndexService { else { sink.occurrence(JetTopLevelExtensionFunctionShortNameIndex.getInstance().getKey(), name); } - - FqName topFQName = stub.getFqName(); - if (topFQName != null) { - sink.occurrence(JetTopLevelFunctionsFqnNameIndex.getInstance().getKey(), topFQName.asString()); - } } - sink.occurrence(JetFunctionShortNameIndex.getInstance().getKey(), name); } + // can have special fq name in case of syntactically incorrect function with no name + FqName topFQName = stub.getFqName(); + if (topFQName != null) { + sink.occurrence(JetTopLevelFunctionsFqnNameIndex.getInstance().getKey(), topFQName.asString()); + } } @Override public void indexProperty(PsiJetPropertyStub stub, IndexSink sink) { String propertyName = stub.getName(); if (propertyName != null) { - if (stub.isTopLevel()) { - FqName topFQName = stub.getFqName(); - if (topFQName != null) { - sink.occurrence(JetTopLevelPropertiesFqnNameIndex.getInstance().getKey(), topFQName.asString()); - } - } - sink.occurrence(JetPropertyShortNameIndex.getInstance().getKey(), propertyName); } + // can have special fq name in case of syntactically incorrect function with no name + if (stub.isTopLevel()) { + FqName topFQName = stub.getFqName(); + if (topFQName != null) { + sink.occurrence(JetTopLevelPropertiesFqnNameIndex.getInstance().getKey(), topFQName.asString()); + } + } } @Override diff --git a/idea/src/org/jetbrains/jet/plugin/stubindex/resolve/AbstractStubDeclarationProvider.java b/idea/src/org/jetbrains/jet/plugin/stubindex/resolve/AbstractStubDeclarationProvider.java deleted file mode 100644 index 57c0e411d7d..00000000000 --- a/idea/src/org/jetbrains/jet/plugin/stubindex/resolve/AbstractStubDeclarationProvider.java +++ /dev/null @@ -1,42 +0,0 @@ -/* - * Copyright 2010-2013 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.jet.plugin.stubindex.resolve; - -import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.psi.JetClassOrObject; -import org.jetbrains.jet.lang.psi.JetDeclaration; -import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProvider; -import org.jetbrains.jet.lang.resolve.name.Name; - -import java.util.Collection; -import java.util.Collections; -import java.util.List; - -public abstract class AbstractStubDeclarationProvider implements DeclarationProvider { - @Override - public List getAllDeclarations() { - // TODO: - return null; - } - - @NotNull - @Override - public Collection getClassOrObjectDeclarations(@NotNull Name name) { - // TODO: - return Collections.emptyList(); - } -} diff --git a/idea/src/org/jetbrains/jet/plugin/stubindex/resolve/CombinedPackageMemberDeclarationProvider.kt b/idea/src/org/jetbrains/jet/plugin/stubindex/resolve/CombinedPackageMemberDeclarationProvider.kt new file mode 100644 index 00000000000..f10926d5e44 --- /dev/null +++ b/idea/src/org/jetbrains/jet/plugin/stubindex/resolve/CombinedPackageMemberDeclarationProvider.kt @@ -0,0 +1,40 @@ +/* + * Copyright 2010-2014 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.jet.plugin.stubindex.resolve + +import com.intellij.psi.NavigatablePsiElement +import org.jetbrains.jet.lang.psi.* +import org.jetbrains.jet.lang.resolve.lazy.declarations.FileBasedPackageMemberDeclarationProvider +import org.jetbrains.jet.lang.resolve.lazy.declarations.PackageMemberDeclarationProvider +import org.jetbrains.jet.lang.resolve.name.FqName +import org.jetbrains.jet.lang.resolve.name.Name + +public class CombinedPackageMemberDeclarationProvider(val providers: Collection) : PackageMemberDeclarationProvider { + override fun getAllDeclaredPackages() = providers.flatMap { it.getAllDeclaredPackages() } + + override fun getPackageDeclarations(fqName: FqName) = providers.flatMap { it.getPackageDeclarations(fqName) } + + override fun getPackageFiles() = providers.flatMap { it.getPackageFiles() } + + override fun getAllDeclarations() = providers.flatMap { it.getAllDeclarations() } + + override fun getFunctionDeclarations(name: Name) = providers.flatMap { it.getFunctionDeclarations(name) } + + override fun getPropertyDeclarations(name: Name) = providers.flatMap { it.getPropertyDeclarations(name) } + + override fun getClassOrObjectDeclarations(name: Name) = providers.flatMap { it.getClassOrObjectDeclarations(name) } +} diff --git a/idea/src/org/jetbrains/jet/plugin/stubindex/resolve/PluginDeclarationProviderFactory.kt b/idea/src/org/jetbrains/jet/plugin/stubindex/resolve/PluginDeclarationProviderFactory.kt new file mode 100644 index 00000000000..f4485f9bd6b --- /dev/null +++ b/idea/src/org/jetbrains/jet/plugin/stubindex/resolve/PluginDeclarationProviderFactory.kt @@ -0,0 +1,61 @@ +/* + * Copyright 2010-2014 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.jet.plugin.stubindex.resolve + +import com.intellij.openapi.project.Project +import com.intellij.psi.search.GlobalSearchScope +import org.jetbrains.annotations.Nullable +import org.jetbrains.jet.lang.psi.JetFile +import org.jetbrains.jet.lang.resolve.lazy.data.JetClassLikeInfo +import org.jetbrains.jet.lang.resolve.lazy.declarations.* +import org.jetbrains.jet.lang.resolve.name.FqName +import org.jetbrains.jet.plugin.stubindex.JetAllPackagesIndex +import org.jetbrains.jet.storage.StorageManager +import java.util.Arrays + +public class PluginDeclarationProviderFactory( + private val project: Project, + private val indexedFilesScope: GlobalSearchScope, + private val storageManager: StorageManager, + private val nonIndexedFiles: Collection +) : AbstractDeclarationProviderFactory(storageManager) { + private val fileBasedDeclarationProviderFactory = FileBasedDeclarationProviderFactory(storageManager, nonIndexedFiles) + + override fun getClassMemberDeclarationProvider(classLikeInfo: JetClassLikeInfo): ClassMemberDeclarationProvider { + return PsiBasedClassMemberDeclarationProvider(storageManager, classLikeInfo) + } + + override fun createPackageMemberDeclarationProvider(name: FqName): PackageMemberDeclarationProvider? { + val fileBasedProvider = fileBasedDeclarationProviderFactory.getPackageMemberDeclarationProvider(name) + val stubBasedProvider = getStubBasedPackageMemberDeclarationProvider(name) + return when { + fileBasedProvider == null && stubBasedProvider == null -> null + fileBasedProvider == null -> stubBasedProvider + stubBasedProvider == null -> fileBasedProvider + else -> CombinedPackageMemberDeclarationProvider(listOf(stubBasedProvider, fileBasedProvider)) + } + } + + private fun getStubBasedPackageMemberDeclarationProvider(name: FqName): PackageMemberDeclarationProvider? { + //TODO: better check + val files = JetAllPackagesIndex.getInstance().get(name.asString(), project, indexedFilesScope) + if (files.isEmpty()) { + return null + } + return StubBasedPackageMemberDeclarationProvider(name, project, indexedFilesScope) + } +} diff --git a/idea/src/org/jetbrains/jet/plugin/stubindex/resolve/PluginDeclarationProviderFactoryService.kt b/idea/src/org/jetbrains/jet/plugin/stubindex/resolve/PluginDeclarationProviderFactoryService.kt new file mode 100644 index 00000000000..c384c7091d8 --- /dev/null +++ b/idea/src/org/jetbrains/jet/plugin/stubindex/resolve/PluginDeclarationProviderFactoryService.kt @@ -0,0 +1,44 @@ +/* + * Copyright 2010-2014 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.jet.plugin.stubindex.resolve + +import com.intellij.openapi.project.Project +import com.intellij.openapi.util.Condition +import com.intellij.openapi.vfs.VirtualFile +import com.intellij.psi.search.GlobalSearchScope +import com.intellij.util.Function +import com.intellij.util.containers.ContainerUtil +import org.jetbrains.jet.lang.psi.JetFile +import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFactory +import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFactoryService +import org.jetbrains.jet.plugin.stubindex.JetSourceFilterScope +import org.jetbrains.jet.storage.StorageManager + +public class PluginDeclarationProviderFactoryService : DeclarationProviderFactoryService() { + + override fun create(project: Project, storageManager: StorageManager, files: Collection): DeclarationProviderFactory { + val indexedSourcesScope = JetSourceFilterScope.kotlinSourcesAndLibraries(GlobalSearchScope.allScope(project)) + val nonIndexedFiles = files.filter { + file -> + !file.isPhysical() || !indexedSourcesScope.contains(file.getVirtualFile()!!) + } + val physicalFilesScope = GlobalSearchScope.filesScope(project, files.filter { it.isPhysical() }.map { it.getVirtualFile()!! }) + val indexedFilesScope = indexedSourcesScope.intersectWith(physicalFilesScope) + + return PluginDeclarationProviderFactory(project, indexedFilesScope, storageManager, nonIndexedFiles) + } +} \ No newline at end of file diff --git a/idea/src/org/jetbrains/jet/plugin/stubindex/resolve/StubBasedPackageMemberDeclarationProvider.kt b/idea/src/org/jetbrains/jet/plugin/stubindex/resolve/StubBasedPackageMemberDeclarationProvider.kt new file mode 100644 index 00000000000..bea13ed89c3 --- /dev/null +++ b/idea/src/org/jetbrains/jet/plugin/stubindex/resolve/StubBasedPackageMemberDeclarationProvider.kt @@ -0,0 +1,99 @@ +/* + * Copyright 2010-2014 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.jet.plugin.stubindex.resolve + +import com.intellij.openapi.project.Project +import com.intellij.psi.NavigatablePsiElement +import com.intellij.psi.search.GlobalSearchScope +import com.intellij.psi.stubs.StringStubIndexExtension +import org.jetbrains.jet.lang.psi.* +import org.jetbrains.jet.lang.resolve.lazy.declarations.PackageMemberDeclarationProvider +import org.jetbrains.jet.lang.resolve.name.FqName +import org.jetbrains.jet.lang.resolve.name.Name +import org.jetbrains.jet.plugin.stubindex.JetAllPackagesIndex +import org.jetbrains.jet.plugin.stubindex.JetFullClassNameIndex +import org.jetbrains.jet.plugin.stubindex.JetTopLevelFunctionsFqnNameIndex +import org.jetbrains.jet.plugin.stubindex.JetTopLevelPropertiesFqnNameIndex +import java.util.* +import org.jetbrains.jet.plugin.stubindex.JetSourceFilterScope.kotlinSources +import org.jetbrains.jet.lang.resolve.name.numberOfSegments + +public class StubBasedPackageMemberDeclarationProvider( + private val fqName: FqName, + private val project: Project, + private val searchScope: GlobalSearchScope +) : PackageMemberDeclarationProvider { + + override fun getAllDeclarations(): List { + return TOP_LEVEL_DECLARATION_INDICES.flatMap { + index -> + val fqNames = index.getAllKeys(project).toSet().map { FqName(it) }.filter { !it.isRoot() && it.parent() == fqName } + fqNames.flatMap { index.get(it.asString(), project, searchScope) } + } + } + + override fun getClassOrObjectDeclarations(name: Name): Collection { + return JetFullClassNameIndex.getInstance().get(childName(name), project, searchScope) + } + + override fun getFunctionDeclarations(name: Name): Collection { + return JetTopLevelFunctionsFqnNameIndex.getInstance().get(childName(name), project, searchScope) + } + + override fun getPropertyDeclarations(name: Name): Collection { + return JetTopLevelPropertiesFqnNameIndex.getInstance().get(childName(name), project, searchScope) + } + + override fun getAllDeclaredPackages(): Collection { + //TODO: duplication with light class generation support + val allPackagesInProject = JetAllPackagesIndex.getInstance().getAllKeys(project) + return allPackagesInProject.filter { + val otherPackageFqName = FqName(it) + !otherPackageFqName.isRoot() && otherPackageFqName.parent() == fqName + }.map { FqName(it) } + } + + override fun getPackageDeclarations(fqName: FqName): Collection { + if (fqName.isRoot()) { + return Collections.emptyList() + } + + val files = JetAllPackagesIndex.getInstance().get(fqName.asString(), project, searchScope) + return files.map { + file -> + JetPsiUtil.getPackageReference(file, fqName.numberOfSegments() - 1) + }.filterNotNull() + } + + override fun getPackageFiles(): Collection { + //TODO: duplicate with light class generation support + val files = JetAllPackagesIndex.getInstance().get(fqName.asString(), project, kotlinSources(searchScope)) + return files.filter { + fqName.equals(JetPsiUtil.getFQName(it)) + } + } + + private fun childName(name: Name): String { + return fqName.child(name).asString() + } +} + +private val TOP_LEVEL_DECLARATION_INDICES: List> = listOf( + JetFullClassNameIndex.getInstance(), + JetTopLevelFunctionsFqnNameIndex.getInstance(), + JetTopLevelPropertiesFqnNameIndex.getInstance() +) \ No newline at end of file diff --git a/idea/src/org/jetbrains/jet/plugin/stubindex/resolve/StubDeclarationProviderFactory.java b/idea/src/org/jetbrains/jet/plugin/stubindex/resolve/StubDeclarationProviderFactory.java deleted file mode 100644 index 1917eca1ad2..00000000000 --- a/idea/src/org/jetbrains/jet/plugin/stubindex/resolve/StubDeclarationProviderFactory.java +++ /dev/null @@ -1,52 +0,0 @@ -/* - * Copyright 2010-2013 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.jet.plugin.stubindex.resolve; - -import com.intellij.openapi.project.Project; -import com.intellij.psi.search.GlobalSearchScope; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.resolve.lazy.data.JetClassLikeInfo; -import org.jetbrains.jet.lang.resolve.lazy.declarations.ClassMemberDeclarationProvider; -import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFactory; -import org.jetbrains.jet.lang.resolve.lazy.declarations.PackageMemberDeclarationProvider; -import org.jetbrains.jet.lang.resolve.lazy.declarations.PsiBasedClassMemberDeclarationProvider; -import org.jetbrains.jet.storage.StorageManager; -import org.jetbrains.jet.lang.resolve.name.FqName; - -public class StubDeclarationProviderFactory implements DeclarationProviderFactory { - - private final Project project; - private final GlobalSearchScope searchScope; - private final StorageManager storageManager; - - public StubDeclarationProviderFactory(@NotNull Project project, @NotNull GlobalSearchScope scope, @NotNull StorageManager manager) { - this.project = project; - searchScope = scope; - storageManager = manager; - } - - @NotNull - @Override - public ClassMemberDeclarationProvider getClassMemberDeclarationProvider(@NotNull JetClassLikeInfo classLikeInfo) { - return new PsiBasedClassMemberDeclarationProvider(storageManager, classLikeInfo); - } - - @Override - public PackageMemberDeclarationProvider getPackageMemberDeclarationProvider(@NotNull FqName packageFqName) { - return new StubPackageMemberDeclarationProvider(packageFqName, project, searchScope); - } -} diff --git a/idea/src/org/jetbrains/jet/plugin/stubindex/resolve/StubPackageMemberDeclarationProvider.java b/idea/src/org/jetbrains/jet/plugin/stubindex/resolve/StubPackageMemberDeclarationProvider.java deleted file mode 100644 index 60709084b69..00000000000 --- a/idea/src/org/jetbrains/jet/plugin/stubindex/resolve/StubPackageMemberDeclarationProvider.java +++ /dev/null @@ -1,99 +0,0 @@ -/* - * Copyright 2010-2014 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.jet.plugin.stubindex.resolve; - -import com.intellij.openapi.project.Project; -import com.intellij.psi.NavigatablePsiElement; -import com.intellij.psi.search.GlobalSearchScope; -import com.intellij.util.Function; -import com.intellij.util.containers.ContainerUtil; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.psi.JetFile; -import org.jetbrains.jet.lang.psi.JetNamedFunction; -import org.jetbrains.jet.lang.psi.JetProperty; -import org.jetbrains.jet.lang.psi.JetPsiUtil; -import org.jetbrains.jet.lang.resolve.lazy.declarations.PackageMemberDeclarationProvider; -import org.jetbrains.jet.lang.resolve.name.FqName; -import org.jetbrains.jet.lang.resolve.name.Name; -import org.jetbrains.jet.plugin.stubindex.JetAllPackagesIndex; -import org.jetbrains.jet.plugin.stubindex.JetTopLevelFunctionsFqnNameIndex; -import org.jetbrains.jet.plugin.stubindex.JetTopLevelPropertiesFqnNameIndex; -import org.jetbrains.jet.lang.resolve.name.NamePackage; - -import java.util.Collection; -import java.util.Collections; - -public class StubPackageMemberDeclarationProvider extends AbstractStubDeclarationProvider implements PackageMemberDeclarationProvider { - private final FqName fqName; - private final Project project; - private final GlobalSearchScope searchScope; - - public StubPackageMemberDeclarationProvider(@NotNull FqName fqName, @NotNull Project project, @NotNull GlobalSearchScope searchScope) { - this.fqName = fqName; - this.project = project; - this.searchScope = searchScope; - } - - @NotNull - @Override - public Collection getFunctionDeclarations(@NotNull Name name) { - return JetTopLevelFunctionsFqnNameIndex.getInstance().get(fqName.child(name).toString(), project, searchScope); - } - - @NotNull - @Override - public Collection getPropertyDeclarations(@NotNull Name name) { - return JetTopLevelPropertiesFqnNameIndex.getInstance().get(fqName.child(name).toString(), project, searchScope); - } - - @Override - public Collection getAllDeclaredPackages() { - // get all packages in this project - Collection allPackagesInProject = JetAllPackagesIndex.getInstance().getAllKeys(project); - return ContainerUtil.mapNotNull(allPackagesInProject, new Function() { - @Override - public FqName fun(String packageFqName) { - // filter by the search scope - Collection files = JetAllPackagesIndex.getInstance().get(packageFqName, project, searchScope); - if (files.isEmpty()) return null; - return new FqName(packageFqName); - } - }); - } - - @NotNull - @Override - public Collection getPackageDeclarations(final FqName fqName) { - if (fqName.isRoot()) { - return Collections.emptyList(); - } - - Collection files = JetAllPackagesIndex.getInstance().get(fqName.asString(), project, searchScope); - return ContainerUtil.map(files, new Function() { - @Override - public NavigatablePsiElement fun(JetFile file) { - return JetPsiUtil.getPackageReference(file, NamePackage.numberOfSegments(fqName) - 1); - } - }); - } - - @NotNull - @Override - public Collection getPackageFiles() { - return JetAllPackagesIndex.getInstance().get(fqName.asString(), project, searchScope); - } -} diff --git a/idea/tests/org/jetbrains/jet/plugin/stubs/resolve/JetStubResolveTest.java b/idea/tests/org/jetbrains/jet/plugin/stubs/resolve/JetStubResolveTest.java index 0c1d0eda900..b520aac6cc3 100644 --- a/idea/tests/org/jetbrains/jet/plugin/stubs/resolve/JetStubResolveTest.java +++ b/idea/tests/org/jetbrains/jet/plugin/stubs/resolve/JetStubResolveTest.java @@ -27,7 +27,7 @@ import org.jetbrains.jet.lang.psi.JetProperty; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.plugin.JetFileType; -import org.jetbrains.jet.plugin.stubindex.resolve.StubPackageMemberDeclarationProvider; +import org.jetbrains.jet.plugin.stubindex.resolve.StubBasedPackageMemberDeclarationProvider; import java.util.Collection; import java.util.List; @@ -37,8 +37,8 @@ public class JetStubResolveTest extends LightCodeInsightFixtureTestCase { myFixture.configureByText(JetFileType.INSTANCE, "package test.testing\n" + "fun some() {}"); - StubPackageMemberDeclarationProvider provider = - new StubPackageMemberDeclarationProvider(new FqName("test.testing"), getProject(), GlobalSearchScope.projectScope(getProject())); + StubBasedPackageMemberDeclarationProvider provider = + new StubBasedPackageMemberDeclarationProvider(new FqName("test.testing"), getProject(), GlobalSearchScope.projectScope(getProject())); List some = Lists.newArrayList(provider.getFunctionDeclarations(Name.identifier("some"))); @@ -52,8 +52,8 @@ public class JetStubResolveTest extends LightCodeInsightFixtureTestCase { "fun other(v : Int) = 12\n" + "fun other(v : String) {}"); - StubPackageMemberDeclarationProvider provider = - new StubPackageMemberDeclarationProvider(new FqName("test.testing"), getProject(), GlobalSearchScope.projectScope(getProject())); + StubBasedPackageMemberDeclarationProvider provider = + new StubBasedPackageMemberDeclarationProvider(new FqName("test.testing"), getProject(), GlobalSearchScope.projectScope(getProject())); List other = Lists.newArrayList(provider.getFunctionDeclarations(Name.identifier("other"))); Collection functionTexts = Collections2.transform(other, new Function() { @@ -73,8 +73,8 @@ public class JetStubResolveTest extends LightCodeInsightFixtureTestCase { "package test.testing\n" + "val test = 12\n"); - StubPackageMemberDeclarationProvider provider = - new StubPackageMemberDeclarationProvider(new FqName("test.testing"), getProject(), GlobalSearchScope.projectScope(getProject())); + StubBasedPackageMemberDeclarationProvider provider = + new StubBasedPackageMemberDeclarationProvider(new FqName("test.testing"), getProject(), GlobalSearchScope.projectScope(getProject())); List testProperties = Lists.newArrayList(provider.getPropertyDeclarations(Name.identifier("test"))); @@ -85,7 +85,7 @@ public class JetStubResolveTest extends LightCodeInsightFixtureTestCase { public void testGetPackageByIntermediatePartition() { myFixture.configureByText(JetFileType.INSTANCE, "package first.second.third"); - StubPackageMemberDeclarationProvider provider = new StubPackageMemberDeclarationProvider( + StubBasedPackageMemberDeclarationProvider provider = new StubBasedPackageMemberDeclarationProvider( new FqName("first.second"), getProject(), GlobalSearchScope.projectScope(getProject())); Collection packageDeclarations = provider.getPackageDeclarations(new FqName("first.second")); diff --git a/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java b/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java index 495fe12ec71..71678e6310e 100644 --- a/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java +++ b/js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java @@ -36,7 +36,7 @@ import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.*; import org.jetbrains.jet.lang.resolve.lazy.ResolveSession; -import org.jetbrains.jet.lang.resolve.lazy.declarations.FileBasedDeclarationProviderFactory; +import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFactory; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.k2js.config.Config; @@ -45,6 +45,8 @@ import java.util.Collection; import java.util.Collections; import java.util.List; +import static org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFactoryService.createDeclarationProviderFactory; + public final class AnalyzerFacadeForJS { public static final List DEFAULT_IMPORTS = ImmutableList.of( new ImportPath("js.*"), @@ -155,8 +157,9 @@ public final class AnalyzerFacadeForJS { @NotNull public static ResolveSession getLazyResolveSession(Collection files, Config config) { GlobalContextImpl globalContext = ContextPackage.GlobalContext(); - FileBasedDeclarationProviderFactory declarationProviderFactory = new FileBasedDeclarationProviderFactory( - globalContext.getStorageManager(), Config.withJsLibAdded(files, config)); + DeclarationProviderFactory declarationProviderFactory = + createDeclarationProviderFactory(config.getProject(), globalContext.getStorageManager(), + Config.withJsLibAdded(files, config)); ModuleDescriptorImpl module = createJsModule(""); module.addFragmentProvider(DependencyKind.BUILT_INS, KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider());