From 2f55959578f08665dd828131e989c06e144da7d3 Mon Sep 17 00:00:00 2001 From: "Pavel V. Talanov" Date: Thu, 30 Jan 2014 16:38:48 +0400 Subject: [PATCH] Refactor: rewrite JetReferenceContributor to kotlin Add additional utilities to track what psi elements are capable of holding references --- .../references/JetReferenceContributor.java | 89 ------------------- .../references/JetReferenceContributor.kt | 62 +++++++++++++ 2 files changed, 62 insertions(+), 89 deletions(-) delete mode 100644 idea/src/org/jetbrains/jet/plugin/references/JetReferenceContributor.java create mode 100644 idea/src/org/jetbrains/jet/plugin/references/JetReferenceContributor.kt diff --git a/idea/src/org/jetbrains/jet/plugin/references/JetReferenceContributor.java b/idea/src/org/jetbrains/jet/plugin/references/JetReferenceContributor.java deleted file mode 100644 index 3fe2176ee0f..00000000000 --- a/idea/src/org/jetbrains/jet/plugin/references/JetReferenceContributor.java +++ /dev/null @@ -1,89 +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.references; - -import com.intellij.psi.*; -import com.intellij.util.ProcessingContext; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.psi.*; - -import static com.intellij.patterns.PlatformPatterns.psiElement; - -public class JetReferenceContributor extends PsiReferenceContributor { - @Override - public void registerReferenceProviders(PsiReferenceRegistrar registrar) { - registrar.registerReferenceProvider(psiElement(JetSimpleNameExpression.class), - new PsiReferenceProvider() { - @NotNull - @Override - public PsiReference[] getReferencesByElement(@NotNull PsiElement element, @NotNull ProcessingContext processingContext) { - return toArray(new JetSimpleNameReference((JetSimpleNameExpression) element)); - } - }); - - registrar.registerReferenceProvider(psiElement(JetThisReferenceExpression.class), - new PsiReferenceProvider() { - @NotNull - @Override - public PsiReference[] getReferencesByElement(@NotNull PsiElement element, @NotNull ProcessingContext processingContext) { - return toArray(new JetThisReference((JetThisReferenceExpression) element)); - } - }); - - registrar.registerReferenceProvider(psiElement(JetArrayAccessExpression.class), - new PsiReferenceProvider() { - @NotNull - @Override - public PsiReference[] getReferencesByElement(@NotNull PsiElement element, @NotNull ProcessingContext processingContext) { - return toArray(new JetArrayAccessReference((JetArrayAccessExpression) element)); - } - }); - - registrar.registerReferenceProvider(psiElement(JetCallExpression.class), - new PsiReferenceProvider() { - @NotNull - @Override - public PsiReference[] getReferencesByElement(@NotNull PsiElement element, @NotNull ProcessingContext processingContext) { - return toArray(new JetInvokeFunctionReference((JetCallExpression) element)); - } - }); - - registrar.registerReferenceProvider(psiElement(JetPropertyDelegate.class), - new PsiReferenceProvider() { - @NotNull - @Override - public PsiReference[] getReferencesByElement(@NotNull PsiElement element, @NotNull ProcessingContext processingContext) { - return toArray( - new JetPropertyDelegationMethodsReference((JetPropertyDelegate) element)); - } - }); - - registrar.registerReferenceProvider(psiElement(JetForExpression.class), - new PsiReferenceProvider() { - @NotNull - @Override - public PsiReference[] getReferencesByElement(@NotNull PsiElement element, @NotNull ProcessingContext processingContext) { - return toArray(new JetForLoopInReference((JetForExpression) element)); - } - }); - } - - @NotNull - private static JetReference[] toArray(@NotNull JetReference reference) { - return new JetReference[] {reference}; - } -} diff --git a/idea/src/org/jetbrains/jet/plugin/references/JetReferenceContributor.kt b/idea/src/org/jetbrains/jet/plugin/references/JetReferenceContributor.kt new file mode 100644 index 00000000000..5af663ee1a3 --- /dev/null +++ b/idea/src/org/jetbrains/jet/plugin/references/JetReferenceContributor.kt @@ -0,0 +1,62 @@ +/* + * 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.references + +import com.intellij.psi.* +import org.jetbrains.jet.lang.psi.* +import com.intellij.util.ProcessingContext +import com.intellij.patterns.PlatformPatterns + +public class JetReferenceContributor() : PsiReferenceContributor() { + public override fun registerReferenceProviders(registrar: PsiReferenceRegistrar?) { + if (registrar == null) { + return + } + with(registrar) { + registerProvider(javaClass()) { + JetSimpleNameReference(it) + } + registerProvider(javaClass()) { + JetThisReference(it) + } + registerProvider(javaClass()) { + JetInvokeFunctionReference(it) + } + registerProvider(javaClass()) { + JetArrayAccessReference(it) + } + registerProvider(javaClass()) { + JetForLoopInReference(it) + } + registerProvider(javaClass()) { + JetPropertyDelegationMethodsReference(it) + } + } + } + + private fun > PsiReferenceRegistrar.registerProvider( + elementClass: Class, + factory: (E) -> R + ) { + registerReferenceProvider(PlatformPatterns.psiElement(elementClass)!!, object: PsiReferenceProvider() { + override fun getReferencesByElement(element: PsiElement, context: ProcessingContext): Array { + [suppress("UNCHECKED_CAST")] + return array(factory(element as E)) + } + }) + } +}