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

Refactoring code in completion

Browse Source
This commit is contained in:
Valentin Kipyatkov
2014-07-30 17:12:29 +04:00
parent 727b4c56d0
commit 7c523df1ca
4 changed files with 41 additions and 47 deletions
Download Patch File Download Diff File Expand all files Collapse all files
idea/src/org/jetbrains/jet/plugin/completion/JetCompletionResultSet.kt → idea/src/org/jetbrains/jet/plugin/completion/CompletionResultSetWrapper.kt
+10 -13
View File
@@ -29,20 +29,19 @@ import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns
import org.jetbrains.jet.plugin.completion.handlers.*
import org.jetbrains.jet.plugin.project.ResolveSessionForBodies
public class JetCompletionResultSet(public val result: CompletionResultSet,
public val resolveSession: ResolveSessionForBodies,
public val bindingContext: BindingContext,
private val descriptorFilter: (DeclarationDescriptor) -> Boolean) {
class CompletionResultSetWrapper(public val resultSet: CompletionResultSet,
private val resolveSession: ResolveSessionForBodies,
private val descriptorFilter: (DeclarationDescriptor) -> Boolean) {
public var isSomethingAdded: Boolean = false
private set
public fun addAllElements(descriptors: Iterable<DeclarationDescriptor>) {
public fun addDescriptorElements(descriptors: Iterable<DeclarationDescriptor>) {
for (descriptor in descriptors) {
addElement(descriptor)
addDescriptorElements(descriptor)
}
}
public fun addElement(descriptor: DeclarationDescriptor) {
public fun addDescriptorElements(descriptor: DeclarationDescriptor) {
if (!descriptorFilter(descriptor)) return
addElement(DescriptorLookupConverter.createLookupElement(resolveSession, descriptor))
@@ -73,11 +72,9 @@ public class JetCompletionResultSet(public val result: CompletionResultSet,
}
public fun addElement(element: LookupElement) {
if (!result.getPrefixMatcher().prefixMatches(element)) return
result.addElement(element)
isSomethingAdded = true
if (resultSet.getPrefixMatcher().prefixMatches(element)) {
resultSet.addElement(element)
isSomethingAdded = true
}
}
public val shortNameFilter: (String) -> Boolean = { result.getPrefixMatcher().prefixMatches(it) }
}
idea/src/org/jetbrains/jet/plugin/completion/CompletionSession.kt
+18 -20
View File
@@ -36,23 +36,21 @@ class CompletionSession(public val parameters: CompletionParameters,
resultSet: CompletionResultSet,
private val jetReference: JetSimpleNameReference,
position: PsiElement) {
private val inDescriptor: DeclarationDescriptor?
public val jetResult: JetCompletionResultSet
private val resolveSession = (position.getContainingFile() as JetFile).getLazyResolveSession()
private val bindingContext = resolveSession.resolveToElement(jetReference.expression)
private val position = parameters.getPosition()
;{
inDescriptor = bindingContext.get<JetExpression, JetScope>(BindingContext.RESOLUTION_SCOPE, jetReference.expression)?.getContainingDeclaration()
private val inDescriptor: DeclarationDescriptor? = bindingContext.get(BindingContext.RESOLUTION_SCOPE, jetReference.expression)?.getContainingDeclaration()
public val result: CompletionResultSetWrapper = run {
// set prefix matcher here to override default one which relies on CompletionUtil.findReferencePrefix()
// which sometimes works incorrectly for Kotlin
var result = resultSet.withPrefixMatcher(CompletionUtil.findJavaIdentifierPrefix(parameters))
result = result.addKotlinSorting(parameters)
this.jetResult = JetCompletionResultSet(result, resolveSession, bindingContext, { isVisibleDescriptor(it) })
CompletionResultSetWrapper(result, resolveSession, { isVisibleDescriptor(it) })
}
public fun completeForReference() {
@@ -62,11 +60,11 @@ class CompletionSession(public val parameters: CompletionParameters,
if (shouldRunOnlyTypeCompletion()) {
if (parameters.getInvocationCount() >= 2) {
JetTypesCompletionHelper.addJetTypes(parameters, jetResult)
TypesCompletion(parameters, resolveSession).addAllTypes(result)
}
else {
addReferenceVariants { isPartOfTypeDeclaration(it) }
JavaCompletionContributor.advertiseSecondCompletion(parameters.getPosition().getProject(), jetResult.result)
JavaCompletionContributor.advertiseSecondCompletion(parameters.getPosition().getProject(), result.resultSet)
}
return
@@ -74,7 +72,7 @@ class CompletionSession(public val parameters: CompletionParameters,
addReferenceVariants { true }
val prefix = jetResult.result.getPrefixMatcher().getPrefix()
val prefix = result.resultSet.getPrefixMatcher().getPrefix()
// Try to avoid computing not-imported descriptors for empty prefix
if (prefix.isEmpty()) {
@@ -84,7 +82,7 @@ class CompletionSession(public val parameters: CompletionParameters,
}
if (shouldRunTopLevelCompletion()) {
JetTypesCompletionHelper.addJetTypes(parameters, jetResult)
TypesCompletion(parameters, resolveSession).addAllTypes(result)
addJetTopLevelFunctions()
addJetTopLevelObjects()
}
@@ -97,9 +95,9 @@ class CompletionSession(public val parameters: CompletionParameters,
public fun completeSmart() {
assert(parameters.getCompletionType() == CompletionType.SMART)
val descriptors = TipsManager.getReferenceVariants(jetReference.expression, jetResult.bindingContext)
val descriptors = TipsManager.getReferenceVariants(jetReference.expression, bindingContext)
val completion = SmartCompletion(jetReference.expression, resolveSession, { isVisibleDescriptor(it) }, parameters.getOriginalFile() as JetFile)
completion.buildLookupElements(descriptors)?.forEach { jetResult.addElement(it) }
completion.buildLookupElements(descriptors)?.forEach { result.addElement(it) }
}
private fun isOnlyKeywordCompletion(position: PsiElement)
@@ -108,7 +106,7 @@ class CompletionSession(public val parameters: CompletionParameters,
private fun addJetExtensions() {
val project = position.getProject()
val namesCache = JetShortNamesCache.getKotlinInstance(project)
jetResult.addAllElements(namesCache.getJetCallableExtensions({ jetResult.shortNameFilter(it!!) }, jetReference.expression, resolveSession, GlobalSearchScope.allScope(project)))
result.addDescriptorElements(namesCache.getJetCallableExtensions({ result.resultSet.getPrefixMatcher().prefixMatches(it!!) }, jetReference.expression, resolveSession, GlobalSearchScope.allScope(project)))
}
private fun isPartOfTypeDeclaration(descriptor: DeclarationDescriptor): Boolean {
@@ -126,7 +124,7 @@ class CompletionSession(public val parameters: CompletionParameters,
}
private fun addJetTopLevelFunctions() {
val actualPrefix = jetResult.result.getPrefixMatcher().getPrefix()
val actualPrefix = result.resultSet.getPrefixMatcher().getPrefix()
val project = position.getProject()
val namesCache = JetShortNamesCache.getKotlinInstance(project)
val scope = GlobalSearchScope.allScope(project)
@@ -135,7 +133,7 @@ class CompletionSession(public val parameters: CompletionParameters,
// TODO: Fix complete extension not only on contains
for (name in functionNames) {
if (name.contains(actualPrefix)) {
jetResult.addAllElements(namesCache.getTopLevelFunctionDescriptorsByName(name, jetReference.expression, resolveSession, scope))
result.addDescriptorElements(namesCache.getTopLevelFunctionDescriptorsByName(name, jetReference.expression, resolveSession, scope))
}
}
}
@@ -147,8 +145,8 @@ class CompletionSession(public val parameters: CompletionParameters,
val objectNames = namesCache.getAllTopLevelObjectNames()
for (name in objectNames) {
if (jetResult.result.getPrefixMatcher().prefixMatches(name)) {
jetResult.addAllElements(namesCache.getTopLevelObjectsByName(name, jetReference.expression, resolveSession, scope))
if (result.resultSet.getPrefixMatcher().prefixMatches(name)) {
result.addDescriptorElements(namesCache.getTopLevelObjectsByName(name, jetReference.expression, resolveSession, scope))
}
}
}
@@ -158,7 +156,7 @@ class CompletionSession(public val parameters: CompletionParameters,
// expression we are at first of it
val typeReference = PsiTreeUtil.getParentOfType(position, javaClass<JetTypeReference>())
if (typeReference != null) {
val firstPartReference = PsiTreeUtil.findChildOfType<JetSimpleNameExpression>(typeReference, javaClass<JetSimpleNameExpression>())
val firstPartReference = PsiTreeUtil.findChildOfType(typeReference, javaClass<JetSimpleNameExpression>())
return firstPartReference == jetReference.expression
}
@@ -179,12 +177,12 @@ class CompletionSession(public val parameters: CompletionParameters,
}
private fun shouldRunExtensionsCompletion(): Boolean {
return parameters.getInvocationCount() > 1 || jetResult.result.getPrefixMatcher().getPrefix().length >= 3
return parameters.getInvocationCount() > 1 || result.resultSet.getPrefixMatcher().getPrefix().length >= 3
}
private fun addReferenceVariants(filterCondition: (DeclarationDescriptor) -> Boolean) {
val descriptors = TipsManager.getReferenceVariants(jetReference.expression, jetResult.bindingContext)
jetResult.addAllElements(descriptors.filter { filterCondition(it) })
val descriptors = TipsManager.getReferenceVariants(jetReference.expression, bindingContext)
result.addDescriptorElements(descriptors.filter { filterCondition(it) })
}
private fun isVisibleDescriptor(descriptor: DeclarationDescriptor): Boolean {
idea/src/org/jetbrains/jet/plugin/completion/JetCompletionContributor.kt
+1 -1
View File
@@ -122,7 +122,7 @@ public class JetCompletionContributor : CompletionContributor() {
if (parameters.getCompletionType() == CompletionType.BASIC) {
session.completeForReference()
if (!session.jetResult.isSomethingAdded && session.parameters.getInvocationCount() < 2) {
if (!session.result.isSomethingAdded && session.parameters.getInvocationCount() < 2) {
// Rerun completion if nothing was found
session = CompletionSession(parameters.withInvocationCount(2), result, jetReference, position)
session.completeForReference()
idea/src/org/jetbrains/jet/plugin/completion/JetTypesCompletionHelper.kt → idea/src/org/jetbrains/jet/plugin/completion/TypesCompletion.kt
+12 -13
View File
@@ -33,34 +33,33 @@ import org.jetbrains.jet.plugin.caches.JetFromJavaDescriptorHelper
import org.jetbrains.jet.plugin.caches.JetShortNamesCache
import org.jetbrains.jet.plugin.completion.handlers.JetJavaClassInsertHandler
import org.jetbrains.jet.plugin.project.ProjectStructureUtil
import org.jetbrains.jet.plugin.project.ResolveSessionForBodies
object JetTypesCompletionHelper {
fun addJetTypes(parameters: CompletionParameters, jetCompletionResult: JetCompletionResultSet) {
assert(parameters.getInvocationCount() >= 2, "Method should be used only for force completion. In other case complete classes from scope")
jetCompletionResult.addAllElements(KotlinBuiltIns.getInstance().getNonPhysicalClasses())
class TypesCompletion(val parameters: CompletionParameters, val resolveSession: ResolveSessionForBodies) {
fun addAllTypes(result: CompletionResultSetWrapper) {
result.addDescriptorElements(KotlinBuiltIns.getInstance().getNonPhysicalClasses())
val project = parameters.getOriginalFile().getProject()
val namesCache = JetShortNamesCache.getKotlinInstance(project)
jetCompletionResult.addAllElements(namesCache.getJetClassesDescriptors({ jetCompletionResult.shortNameFilter(it!!) }, jetCompletionResult.resolveSession, GlobalSearchScope.allScope(project)))
result.addDescriptorElements(namesCache.getJetClassesDescriptors({ result.resultSet.getPrefixMatcher().prefixMatches(it!!) }, resolveSession, GlobalSearchScope.allScope(project)))
if (!ProjectStructureUtil.isJsKotlinModule(parameters.getOriginalFile() as JetFile)) {
addAdaptedJavaCompletion(parameters, jetCompletionResult)
addAdaptedJavaCompletion(result)
}
}
/**
* Add java elements with performing conversion to kotlin elements if necessary.
*/
private fun addAdaptedJavaCompletion(parameters: CompletionParameters, jetCompletionResult: JetCompletionResultSet) {
JavaClassNameCompletionContributor.addAllClasses(parameters, false, JavaCompletionSorting.addJavaSorting(parameters, jetCompletionResult.result).getPrefixMatcher(), object : Consumer<LookupElement> {
private fun addAdaptedJavaCompletion(result: CompletionResultSetWrapper) {
JavaClassNameCompletionContributor.addAllClasses(parameters, false, JavaCompletionSorting.addJavaSorting(parameters, result.resultSet).getPrefixMatcher(), object : Consumer<LookupElement> {
override fun consume(lookupElement: LookupElement?) {
if (lookupElement is JavaPsiClassReferenceElement) {
val psiClass = lookupElement.getObject()
if (addJavaClassAsJetLookupElement(psiClass, jetCompletionResult)) return
if (addJavaClassAsJetLookupElement(psiClass, result)) return
jetCompletionResult.addElement(object : LookupElementDecorator<LookupElement>(lookupElement) {
result.addElement(object : LookupElementDecorator<LookupElement>(lookupElement) {
override fun handleInsert(context: InsertionContext) {
JetJavaClassInsertHandler.handleInsert(context, lookupElement)
}
@@ -70,7 +69,7 @@ object JetTypesCompletionHelper {
})
}
private fun addJavaClassAsJetLookupElement(aClass: PsiClass, jetCompletionResult: JetCompletionResultSet): Boolean {
private fun addJavaClassAsJetLookupElement(aClass: PsiClass, result: CompletionResultSetWrapper): Boolean {
if (aClass is KotlinLightClass) {
// Do nothing. Kotlin not-compiled class should have already been added as kotlin element before.
return true
@@ -80,7 +79,7 @@ object JetTypesCompletionHelper {
if (JetFromJavaDescriptorHelper.getCompiledClassKind(aClass) != ClassKind.CLASS_OBJECT) {
val qualifiedName = aClass.getQualifiedName()
if (qualifiedName != null) {
jetCompletionResult.addAllElements(ResolveSessionUtils.getClassDescriptorsByFqName(jetCompletionResult.resolveSession, FqName(qualifiedName)))
result.addDescriptorElements(ResolveSessionUtils.getClassDescriptorsByFqName(resolveSession, FqName(qualifiedName)))
}
}