[RESTORED] Spring Support: Implement Spring-specific references

idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/AbstractKotlinReferenceContributor.kt

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2010-2016 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.idea.references
+
+import com.intellij.patterns.ElementPattern
+import com.intellij.patterns.PlatformPatterns
+import com.intellij.psi.*
+import com.intellij.util.ProcessingContext
+import org.jetbrains.kotlin.psi.KtElement
+
+abstract class AbstractKotlinReferenceContributor : PsiReferenceContributor() {
+    protected inline fun <reified E : KtElement> PsiReferenceRegistrar.registerProvider(
+            priority: Double = PsiReferenceRegistrar.DEFAULT_PRIORITY,
+            crossinline factory: (E) -> PsiReference?
+    ) {
+        registerMultiProvider<E>(priority) { factory(it)?.let { arrayOf(it) } ?: PsiReference.EMPTY_ARRAY }
+    }
+
+    protected inline fun <reified E : KtElement> PsiReferenceRegistrar.registerMultiProvider(
+            priority: Double = PsiReferenceRegistrar.DEFAULT_PRIORITY,
+            crossinline factory: (E) -> Array<PsiReference>
+    ) {
+        registerMultiProvider(PlatformPatterns.psiElement(E::class.java), priority, factory)
+    }
+
+    protected inline fun <E : KtElement> PsiReferenceRegistrar.registerMultiProvider(
+            pattern: ElementPattern<E>,
+            priority: Double = PsiReferenceRegistrar.DEFAULT_PRIORITY,
+            crossinline factory: (E) -> Array<PsiReference>
+    ) {
+        registerReferenceProvider(
+                pattern,
+                object : PsiReferenceProvider() {
+                    override fun getReferencesByElement(element: PsiElement, context: ProcessingContext): Array<PsiReference> {
+                        @Suppress("UNCHECKED_CAST")
+                        return factory(element as E)
+                    }
+                },
+                priority
+        )
+    }
+}

idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/KotlinReferenceContributor.kt

@@ -16,22 +16,21 @@
 
 package org.jetbrains.kotlin.idea.references
 
-import com.intellij.patterns.PlatformPatterns
-import com.intellij.psi.*
-import com.intellij.util.ProcessingContext
+import com.intellij.psi.PsiReference
+import com.intellij.psi.PsiReferenceRegistrar
 import org.jetbrains.kotlin.idea.kdoc.KDocReference
 import org.jetbrains.kotlin.kdoc.psi.impl.KDocName
 import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
 
-class KotlinReferenceContributor() : PsiReferenceContributor() {
+class KotlinReferenceContributor() : AbstractKotlinReferenceContributor() {
     override fun registerReferenceProviders(registrar: PsiReferenceRegistrar) {
         with(registrar) {
-            registerProvider(KtSimpleNameExpression::class.java) {
+            registerProvider<KtSimpleNameExpression> {
                 KtSimpleNameReference(it)
             }
 
-            registerMultiProvider(KtNameReferenceExpression::class.java) {
+            registerMultiProvider<KtNameReferenceExpression> {
                 if (it.getReferencedNameElementType() != KtTokens.IDENTIFIER) return@registerMultiProvider emptyArray()
 
                 when (it.readWriteAccess(useResolveForReadWrite = false)) {
@@ -44,46 +43,33 @@ class KotlinReferenceContributor() : PsiReferenceContributor() {
                 }
             }
 
-            registerProvider(KtConstructorDelegationReferenceExpression::class.java) {
+            registerProvider<KtConstructorDelegationReferenceExpression> {
                 KtConstructorDelegationReference(it)
             }
 
-            registerProvider(KtCallExpression::class.java) {
+            registerProvider<KtCallExpression> {
                 KtInvokeFunctionReference(it)
             }
 
-            registerProvider(KtArrayAccessExpression::class.java) {
+            registerProvider<KtArrayAccessExpression> {
                 KtArrayAccessReference(it)
             }
 
-            registerProvider(KtForExpression::class.java) {
+            registerProvider<KtForExpression> {
                 KtForLoopInReference(it)
             }
 
-            registerProvider(KtPropertyDelegate::class.java) {
+            registerProvider<KtPropertyDelegate> {
                 KtPropertyDelegationMethodsReference(it)
             }
 
-            registerProvider(KtDestructuringDeclaration::class.java) {
+            registerProvider<KtDestructuringDeclaration> {
                 KtDestructuringDeclarationReference(it)
             }
 
-            registerProvider(KDocName::class.java) {
+            registerProvider<KDocName> {
                 KDocReference(it)
             }
         }
     }
-
-    private fun <E : KtElement> PsiReferenceRegistrar.registerProvider(elementClass: Class<E>, factory: (E) -> KtReference) {
-        registerMultiProvider(elementClass, { arrayOf(factory(it)) })
-    }
-
-    private fun <E : KtElement> PsiReferenceRegistrar.registerMultiProvider(elementClass: Class<E>, factory: (E) -> Array<PsiReference>) {
-        registerReferenceProvider(PlatformPatterns.psiElement(elementClass), object: PsiReferenceProvider() {
-            override fun getReferencesByElement(element: PsiElement, context: ProcessingContext): Array<PsiReference> {
-                @Suppress("UNCHECKED_CAST")
-                return factory(element as E)
-            }
-        })
-    }
 }