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

Converted ResolveElementCache to Kotlin (step 1)

Browse Source
This commit is contained in:
Valentin Kipyatkov
2015-07-13 14:37:42 +03:00
parent 5735248be8
commit bf7afae805
1 changed files with 58 additions and 86 deletions
Download Patch File Download Diff File Expand all files Collapse all files
idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/ResolveElementCache.java
+58 -86
View File
@@ -14,113 +14,85 @@
* limitations under the License. * limitations under the License.
*/ */
package org.jetbrains.kotlin.idea.project; package org.jetbrains.kotlin.idea.project
import com.intellij.openapi.project.Project; import com.intellij.openapi.project.Project
import com.intellij.psi.util.CachedValue; import com.intellij.psi.util.CachedValue
import com.intellij.psi.util.CachedValueProvider; import com.intellij.psi.util.CachedValueProvider
import com.intellij.psi.util.CachedValuesManager; import com.intellij.psi.util.CachedValuesManager
import com.intellij.psi.util.PsiModificationTracker; import com.intellij.psi.util.PsiModificationTracker
import kotlin.jvm.functions.Function1; import org.jetbrains.kotlin.descriptors.ModuleDescriptor
import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.idea.stubindex.JetProbablyNothingFunctionShortNameIndex
import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.idea.stubindex.JetProbablyNothingPropertyShortNameIndex
import org.jetbrains.kotlin.descriptors.ModuleDescriptor; import org.jetbrains.kotlin.psi.JetElement
import org.jetbrains.kotlin.idea.stubindex.JetProbablyNothingFunctionShortNameIndex; import org.jetbrains.kotlin.psi.JetFile
import org.jetbrains.kotlin.idea.stubindex.JetProbablyNothingPropertyShortNameIndex; import org.jetbrains.kotlin.psi.JetNamedFunction
import org.jetbrains.kotlin.psi.JetElement; import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider
import org.jetbrains.kotlin.psi.JetFile; import org.jetbrains.kotlin.resolve.BindingContext
import org.jetbrains.kotlin.psi.JetNamedFunction; import org.jetbrains.kotlin.resolve.BodyResolveCache
import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider; import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
import org.jetbrains.kotlin.resolve.BindingContext; import org.jetbrains.kotlin.resolve.lazy.ElementResolver
import org.jetbrains.kotlin.resolve.BodyResolveCache; import org.jetbrains.kotlin.resolve.lazy.ProbablyNothingCallableNames
import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode; import org.jetbrains.kotlin.resolve.lazy.ResolveSession
import org.jetbrains.kotlin.resolve.lazy.ElementResolver; import org.jetbrains.kotlin.storage.LazyResolveStorageManager
import org.jetbrains.kotlin.resolve.lazy.ProbablyNothingCallableNames; import org.jetbrains.kotlin.storage.MemoizedFunctionToNotNull
import org.jetbrains.kotlin.resolve.lazy.ResolveSession; import org.jetbrains.kotlin.types.DynamicTypesSettings
import org.jetbrains.kotlin.storage.LazyResolveStorageManager;
import org.jetbrains.kotlin.storage.MemoizedFunctionToNotNull;
import org.jetbrains.kotlin.types.DynamicTypesSettings;
import java.util.Collection; public class ResolveElementCache(resolveSession: ResolveSession, private val project: Project) : ElementResolver(resolveSession), BodyResolveCache {
private val additionalResolveCache: CachedValue<MemoizedFunctionToNotNull<JetElement, BindingContext>>
public class ResolveElementCache extends ElementResolver implements BodyResolveCache { init {
private final Project project;
private final CachedValue<MemoizedFunctionToNotNull<JetElement, BindingContext>> additionalResolveCache;
public ResolveElementCache(ResolveSession resolveSession, Project project) {
super(resolveSession);
this.project = project;
// Recreate internal cache after change of modification count // Recreate internal cache after change of modification count
this.additionalResolveCache = this.additionalResolveCache = CachedValuesManager.getManager(project).createCachedValue(object : CachedValueProvider<MemoizedFunctionToNotNull<JetElement, BindingContext>> {
CachedValuesManager.getManager(project).createCachedValue(new CachedValueProvider<MemoizedFunctionToNotNull<JetElement, BindingContext>>() { override fun compute(): CachedValueProvider.Result<MemoizedFunctionToNotNull<JetElement, BindingContext>>? {
@Nullable val resolveSession = this@ResolveElementCache.resolveSession
@Override val manager = resolveSession.getStorageManager()
public Result<MemoizedFunctionToNotNull<JetElement, BindingContext>> compute() { val elementsCacheFunction = manager.createSoftlyRetainedMemoizedFunction(object : Function1<JetElement, BindingContext> {
ResolveSession resolveSession = ResolveElementCache.this.getResolveSession(); override fun invoke(jetElement: JetElement): BindingContext {
LazyResolveStorageManager manager = resolveSession.getStorageManager(); return performElementAdditionalResolve(jetElement, jetElement, BodyResolveMode.FULL)
MemoizedFunctionToNotNull<JetElement, BindingContext> elementsCacheFunction = }
manager.createSoftlyRetainedMemoizedFunction(new Function1<JetElement, BindingContext>() { })
@Override
public BindingContext invoke(JetElement jetElement) {
return performElementAdditionalResolve(jetElement, jetElement, BodyResolveMode.FULL);
}
});
return Result.create(elementsCacheFunction, return CachedValueProvider.Result.create(elementsCacheFunction,
PsiModificationTracker.MODIFICATION_COUNT, PsiModificationTracker.MODIFICATION_COUNT,
resolveSession.getExceptionTracker()); resolveSession.getExceptionTracker())
} }
}, },
false); false)
} }
@NotNull override fun getElementAdditionalResolve(jetElement: JetElement): BindingContext {
@Override return additionalResolveCache.getValue().invoke(jetElement)
public BindingContext getElementAdditionalResolve(@NotNull JetElement jetElement) {
return additionalResolveCache.getValue().invoke(jetElement);
} }
@Override override fun hasElementAdditionalResolveCached(jetElement: JetElement): Boolean {
public boolean hasElementAdditionalResolveCached(@NotNull JetElement jetElement) { if (!additionalResolveCache.hasUpToDateValue()) return false
if (!additionalResolveCache.hasUpToDateValue()) return false; return additionalResolveCache.getValue().isComputed(jetElement)
return additionalResolveCache.getValue().isComputed(jetElement);
} }
@NotNull override fun createAdditionalCheckerProvider(jetFile: JetFile, module: ModuleDescriptor): AdditionalCheckerProvider {
@Override return TargetPlatformDetector.getPlatform(jetFile).createAdditionalCheckerProvider(module)
public AdditionalCheckerProvider createAdditionalCheckerProvider(@NotNull JetFile jetFile, @NotNull ModuleDescriptor module) {
return TargetPlatformDetector.getPlatform(jetFile).createAdditionalCheckerProvider(module);
} }
@NotNull override fun getDynamicTypesSettings(jetFile: JetFile): DynamicTypesSettings {
@Override return TargetPlatformDetector.getPlatform(jetFile).getDynamicTypesSettings()
public DynamicTypesSettings getDynamicTypesSettings(@NotNull JetFile jetFile) {
return TargetPlatformDetector.getPlatform(jetFile).getDynamicTypesSettings();
} }
@NotNull override fun probablyNothingCallableNames(): ProbablyNothingCallableNames {
@Override return object : ProbablyNothingCallableNames {
protected ProbablyNothingCallableNames probablyNothingCallableNames() { override fun functionNames(): Collection<String> {
return new ProbablyNothingCallableNames() {
@NotNull
@Override
public Collection<String> functionNames() {
// we have to add hardcoded-names until we have Kotlin compiled classes in caches // we have to add hardcoded-names until we have Kotlin compiled classes in caches
return JetProbablyNothingFunctionShortNameIndex.getInstance().getAllKeys(project); return JetProbablyNothingFunctionShortNameIndex.getInstance().getAllKeys(project)
} }
@NotNull override fun propertyNames(): Collection<String> {
@Override return JetProbablyNothingPropertyShortNameIndex.getInstance().getAllKeys(project)
public Collection<String> propertyNames() {
return JetProbablyNothingPropertyShortNameIndex.getInstance().getAllKeys(project);
} }
}; }
} }
@NotNull override fun resolveFunctionBody(function: JetNamedFunction): BindingContext {
@Override return getElementAdditionalResolve(function)
public BindingContext resolveFunctionBody(@NotNull JetNamedFunction function) {
return getElementAdditionalResolve(function);
} }
} }