From 88b8652ed2d0108104ffdea3359efc49ca05d405 Mon Sep 17 00:00:00 2001 From: Mikhail Glukhikh Date: Tue, 20 Feb 2018 18:14:40 +0300 Subject: [PATCH] J2K: convert + get rid of analyzeFully (3 files) --- .../idea/highlighter/DebugInfoAnnotator.kt | 88 +++++++++---------- .../DuplicateJvmSignatureAnnotator.kt | 57 ++++++------ .../internal/CopyAsDiagnosticTestAction.kt | 66 ++++++-------- 3 files changed, 96 insertions(+), 115 deletions(-) diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/DebugInfoAnnotator.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/DebugInfoAnnotator.kt index c9424b87c88..6f0d343e053 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/DebugInfoAnnotator.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/DebugInfoAnnotator.kt @@ -14,72 +14,66 @@ * limitations under the License. */ -package org.jetbrains.kotlin.idea.highlighter; +package org.jetbrains.kotlin.idea.highlighter -import com.intellij.lang.annotation.AnnotationHolder; -import com.intellij.lang.annotation.Annotator; -import com.intellij.openapi.progress.ProcessCanceledException; -import com.intellij.psi.PsiElement; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.kotlin.checkers.DebugInfoUtil; -import org.jetbrains.kotlin.idea.actions.internal.KotlinInternalMode; -import org.jetbrains.kotlin.idea.caches.resolve.ResolutionUtils; -import org.jetbrains.kotlin.idea.util.ProjectRootsUtil; -import org.jetbrains.kotlin.psi.KtCodeFragment; -import org.jetbrains.kotlin.psi.KtFile; -import org.jetbrains.kotlin.psi.KtReferenceExpression; -import org.jetbrains.kotlin.resolve.BindingContext; +import com.intellij.lang.annotation.AnnotationHolder +import com.intellij.lang.annotation.Annotator +import com.intellij.openapi.progress.ProcessCanceledException +import com.intellij.psi.PsiElement +import org.jetbrains.kotlin.checkers.DebugInfoUtil +import org.jetbrains.kotlin.idea.actions.internal.KotlinInternalMode +import org.jetbrains.kotlin.idea.caches.resolve.* +import org.jetbrains.kotlin.idea.util.ProjectRootsUtil +import org.jetbrains.kotlin.psi.KtCodeFragment +import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.psi.KtReferenceExpression /** * Quick showing possible problems with Kotlin internals in IDEA with tooltips */ -public class DebugInfoAnnotator implements Annotator { +class DebugInfoAnnotator : Annotator { - public static boolean isDebugInfoEnabled() { - return KotlinInternalMode.Instance.getEnabled(); - } - - @Override - public void annotate(@NotNull PsiElement element, @NotNull final AnnotationHolder holder) { - if (!isDebugInfoEnabled() || !ProjectRootsUtil.isInProjectOrLibSource(element)) { - return; + override fun annotate(element: PsiElement, holder: AnnotationHolder) { + if (!isDebugInfoEnabled || !ProjectRootsUtil.isInProjectOrLibSource(element)) { + return } - if (element instanceof KtFile && !(element instanceof KtCodeFragment)) { - KtFile file = (KtFile) element; + if (element is KtFile && element !is KtCodeFragment) { try { - BindingContext bindingContext = ResolutionUtils.analyzeFully(file); - DebugInfoUtil.markDebugAnnotations(file, bindingContext, new DebugInfoUtil.DebugInfoReporter() { - @Override - public void reportElementWithErrorType(@NotNull KtReferenceExpression expression) { - holder.createErrorAnnotation(expression, "[DEBUG] Resolved to error element") - .setTextAttributes(KotlinHighlightingColors.RESOLVED_TO_ERROR); + val bindingContext = element.analyzeWithDeclarations() + DebugInfoUtil.markDebugAnnotations(element, bindingContext, object : DebugInfoUtil.DebugInfoReporter() { + override fun reportElementWithErrorType(expression: KtReferenceExpression) { + holder.createErrorAnnotation(expression, "[DEBUG] Resolved to error element").textAttributes = + KotlinHighlightingColors.RESOLVED_TO_ERROR } - @Override - public void reportMissingUnresolved(@NotNull KtReferenceExpression expression) { - holder.createErrorAnnotation(expression, - "[DEBUG] Reference is not resolved to anything, but is not marked unresolved") - .setTextAttributes(KotlinHighlightingColors.DEBUG_INFO); + override fun reportMissingUnresolved(expression: KtReferenceExpression) { + holder.createErrorAnnotation( + expression, + "[DEBUG] Reference is not resolved to anything, but is not marked unresolved" + ).textAttributes = KotlinHighlightingColors.DEBUG_INFO } - @Override - public void reportUnresolvedWithTarget(@NotNull KtReferenceExpression expression, @NotNull String target) { + override fun reportUnresolvedWithTarget(expression: KtReferenceExpression, target: String) { holder.createErrorAnnotation(expression, "[DEBUG] Reference marked as unresolved is actually resolved to " + target) - .setTextAttributes(KotlinHighlightingColors.DEBUG_INFO); + .textAttributes = + KotlinHighlightingColors.DEBUG_INFO } - }); - } - catch (ProcessCanceledException e) { - throw e; - } - catch (Throwable e) { + }) + } catch (e: ProcessCanceledException) { + throw e + } catch (e: Throwable) { // TODO - holder.createErrorAnnotation(element, e.getClass().getCanonicalName() + ": " + e.getMessage()); - e.printStackTrace(); + holder.createErrorAnnotation(element, e.javaClass.canonicalName + ": " + e.message) + e.printStackTrace() } + } } + companion object { + val isDebugInfoEnabled: Boolean + get() = KotlinInternalMode.enabled + } } diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/DuplicateJvmSignatureAnnotator.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/DuplicateJvmSignatureAnnotator.kt index 7ee3475dc85..2fd055bbad8 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/DuplicateJvmSignatureAnnotator.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/DuplicateJvmSignatureAnnotator.kt @@ -14,39 +14,38 @@ * limitations under the License. */ -package org.jetbrains.kotlin.idea.highlighter; +package org.jetbrains.kotlin.idea.highlighter -import com.intellij.lang.annotation.AnnotationHolder; -import com.intellij.lang.annotation.Annotator; -import com.intellij.psi.PsiElement; -import com.intellij.psi.PsiFile; -import com.intellij.psi.search.GlobalSearchScope; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.kotlin.asJava.DuplicateJvmSignatureUtilKt; -import org.jetbrains.kotlin.idea.caches.resolve.GetModuleInfoKt; -import org.jetbrains.kotlin.idea.caches.resolve.ResolutionUtils; -import org.jetbrains.kotlin.idea.project.TargetPlatformDetector; -import org.jetbrains.kotlin.idea.util.ProjectRootsUtil; -import org.jetbrains.kotlin.psi.KtDeclaration; -import org.jetbrains.kotlin.psi.KtElement; -import org.jetbrains.kotlin.psi.KtFile; -import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics; -import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform; +import com.intellij.lang.annotation.AnnotationHolder +import com.intellij.lang.annotation.Annotator +import com.intellij.psi.PsiElement +import org.jetbrains.kotlin.asJava.getJvmSignatureDiagnostics +import org.jetbrains.kotlin.idea.caches.resolve.analyzeWithContent +import org.jetbrains.kotlin.idea.caches.resolve.analyzeWithDeclarations +import org.jetbrains.kotlin.idea.caches.resolve.getModuleInfo +import org.jetbrains.kotlin.idea.project.TargetPlatformDetector +import org.jetbrains.kotlin.idea.util.ProjectRootsUtil +import org.jetbrains.kotlin.psi.KtDeclaration +import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform -public class DuplicateJvmSignatureAnnotator implements Annotator { - @Override - public void annotate(@NotNull PsiElement element, @NotNull AnnotationHolder holder) { - if (!(element instanceof KtFile) && !(element instanceof KtDeclaration)) return; - if (!ProjectRootsUtil.isInProjectSource(element)) return; +class DuplicateJvmSignatureAnnotator : Annotator { + override fun annotate(element: PsiElement, holder: AnnotationHolder) { + if (element !is KtFile && element !is KtDeclaration) return + if (!ProjectRootsUtil.isInProjectSource(element)) return - PsiFile file = element.getContainingFile(); - if (!(file instanceof KtFile) || TargetPlatformDetector.getPlatform((KtFile) file) != JvmPlatform.INSTANCE) return; + val file = element.containingFile + if (file !is KtFile || TargetPlatformDetector.getPlatform(file) !== JvmPlatform) return - Diagnostics otherDiagnostics = ResolutionUtils.analyzeFully((KtElement) element).getDiagnostics(); - GlobalSearchScope moduleScope = GetModuleInfoKt.getModuleInfo(element).contentScope(); - Diagnostics diagnostics = DuplicateJvmSignatureUtilKt.getJvmSignatureDiagnostics(element, otherDiagnostics, moduleScope); + val otherDiagnostics = when (element) { + is KtDeclaration -> element.analyzeWithContent() + is KtFile -> element.analyzeWithDeclarations() + else -> throw AssertionError("DuplicateJvmSignatureAnnotator: should not get here! Element: ${element.text}") + }.diagnostics - if (diagnostics == null) return; - new KotlinPsiChecker().annotateElement(element, holder, diagnostics); + val moduleScope = element.getModuleInfo().contentScope() + val diagnostics = getJvmSignatureDiagnostics(element, otherDiagnostics, moduleScope) ?: return + + KotlinPsiChecker().annotateElement(element, holder, diagnostics) } } diff --git a/idea/src/org/jetbrains/kotlin/idea/actions/internal/CopyAsDiagnosticTestAction.kt b/idea/src/org/jetbrains/kotlin/idea/actions/internal/CopyAsDiagnosticTestAction.kt index 1b53e70b108..8c92000e5ab 100644 --- a/idea/src/org/jetbrains/kotlin/idea/actions/internal/CopyAsDiagnosticTestAction.kt +++ b/idea/src/org/jetbrains/kotlin/idea/actions/internal/CopyAsDiagnosticTestAction.kt @@ -14,52 +14,40 @@ * limitations under the License. */ -package org.jetbrains.kotlin.idea.actions.internal; +package org.jetbrains.kotlin.idea.actions.internal -import com.intellij.openapi.actionSystem.AnAction; -import com.intellij.openapi.actionSystem.AnActionEvent; -import com.intellij.openapi.actionSystem.CommonDataKeys; -import com.intellij.openapi.application.ApplicationManager; -import com.intellij.openapi.editor.Editor; -import com.intellij.psi.PsiFile; -import org.jetbrains.kotlin.checkers.CheckerTestUtil; -import org.jetbrains.kotlin.idea.caches.resolve.ResolutionUtils; -import org.jetbrains.kotlin.psi.KtFile; -import org.jetbrains.kotlin.resolve.BindingContext; +import com.intellij.openapi.actionSystem.AnAction +import com.intellij.openapi.actionSystem.AnActionEvent +import com.intellij.openapi.actionSystem.CommonDataKeys +import com.intellij.openapi.application.ApplicationManager +import org.jetbrains.kotlin.checkers.CheckerTestUtil +import org.jetbrains.kotlin.idea.caches.resolve.* +import org.jetbrains.kotlin.psi.KtFile +import java.awt.* +import java.awt.datatransfer.StringSelection -import java.awt.*; -import java.awt.datatransfer.Clipboard; -import java.awt.datatransfer.ClipboardOwner; -import java.awt.datatransfer.StringSelection; -import java.awt.datatransfer.Transferable; -import java.util.List; +class CopyAsDiagnosticTestAction : AnAction() { + override fun actionPerformed(e: AnActionEvent) { + val editor = e.getData(CommonDataKeys.EDITOR) + val psiFile = e.getData(CommonDataKeys.PSI_FILE) + assert(editor != null && psiFile != null) -public class CopyAsDiagnosticTestAction extends AnAction { - @Override - public void actionPerformed(AnActionEvent e) { - Editor editor = e.getData(CommonDataKeys.EDITOR); - PsiFile psiFile = e.getData(CommonDataKeys.PSI_FILE); - assert editor != null && psiFile != null; + val bindingContext = (psiFile as KtFile).analyzeWithDeclarations() - BindingContext bindingContext = ResolutionUtils.analyzeFully((KtFile) psiFile); + val diagnostics = CheckerTestUtil.getDiagnosticsIncludingSyntaxErrors( + bindingContext, psiFile, false, null, null, false + ) + val result = CheckerTestUtil.addDiagnosticMarkersToText(psiFile, diagnostics).toString() - List diagnostics = - CheckerTestUtil.getDiagnosticsIncludingSyntaxErrors(bindingContext, psiFile, false, null, null, false); - String result = CheckerTestUtil.addDiagnosticMarkersToText(psiFile, diagnostics).toString(); - - Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard(); - clipboard.setContents(new StringSelection(result), new ClipboardOwner() { - @Override - public void lostOwnership(Clipboard clipboard, Transferable contents) {} - }); + val clipboard = Toolkit.getDefaultToolkit().systemClipboard + clipboard.setContents(StringSelection(result)) { _, _ -> } } - @Override - public void update(AnActionEvent e) { - e.getPresentation().setVisible(ApplicationManager.getApplication().isInternal()); + override fun update(e: AnActionEvent) { + e.presentation.isVisible = ApplicationManager.getApplication().isInternal - Editor editor = e.getData(CommonDataKeys.EDITOR); - PsiFile psiFile = e.getData(CommonDataKeys.PSI_FILE); - e.getPresentation().setEnabled(editor != null && psiFile instanceof KtFile); + val editor = e.getData(CommonDataKeys.EDITOR) + val psiFile = e.getData(CommonDataKeys.PSI_FILE) + e.presentation.isEnabled = editor != null && psiFile is KtFile } }