J2K: convert + get rid of analyzeFully (3 files)

2018-02-20 18:14:40 +03:00
parent 50ce8d68bf
commit 88b8652ed2
3 changed files with 96 additions and 115 deletions
@@ -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
+    }
 }
@@ -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)
    }
 }
@@ -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<CheckerTestUtil.ActualDiagnostic> 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
    }
 }