check valid virtual file

Author: shalom938

ide-common/src/main/kotlin/org/digma/intellij/plugin/document/DocumentInfoStorage.kt

@@ -42,18 +42,16 @@ class DocumentInfoStorage(private val project: Project) {
     //initially I wanted to keep putDocumentInfo internal because there is no reason to put a documentInfo from other classes
     // other than EditorDocumentService. but this is a solution for the Rider issue. see comment in call site.
     fun updateDocumentInfoForRider(file: VirtualFile, documentInfo: DocumentInfo) {
-        if (logger.isTraceEnabled) {
-            Log.log(logger::trace, "updateDocumentInfoForRider: {} , DocumentInfo:[{}]", file, documentInfo)
-        }
+        Log.trace(logger, project, "updateDocumentInfoForRider: {} , DocumentInfo:[{}]", file, documentInfo)
         putDocumentInfo(file, documentInfo)
     }
 
     internal fun putDocumentInfo(file: VirtualFile, documentInfo: DocumentInfo) {
 
         if (logger.isTraceEnabled) {
-            Log.log(logger::trace, "putDocumentInfo: {} , DocumentInfo:[{}]", file, documentInfo)
+            Log.trace(logger, project, "putDocumentInfo: {} , DocumentInfo:[{}]", file, documentInfo)
             if (containsDocumentInfo(file)) {
-                Log.log(logger::trace, "putDocumentInfo: file already exists , assuming update. {}", file)
+                Log.trace(logger, project, "putDocumentInfo: file already exists , assuming update. {}", file)
             }
         }
 
@@ -79,17 +77,15 @@ class DocumentInfoStorage(private val project: Project) {
         file: VirtualFile,
         documentInfo: DocumentInfo
     ) {
-        if (logger.isTraceEnabled) {
-            Log.log(logger::trace, "fireDocumentInfoChanged: for {}", file)
-        }
+        Log.trace(logger, project, "fireDocumentInfoChanged: for {}", file)
         project.messageBus.syncPublisher(DocumentInfoChanged.DOCUMENT_INFO_CHANGED_TOPIC).documentInfoChanged(file, documentInfo)
     }
 
 
     internal fun removeDocumentInfo(file: VirtualFile) {
         documentInfos.remove(file)
         if (logger.isTraceEnabled) {
-            Log.log(logger::trace, "removeDocumentInfo: file:{}", file)
+            Log.trace(logger, project, "removeDocumentInfo: file:{}", file)
             Log.log(
                 logger::trace,
                 "currently have {} documents in storage: {}",
@@ -101,9 +97,7 @@ class DocumentInfoStorage(private val project: Project) {
     }
 
     private fun fireDocumentInfoRemoved(file: VirtualFile) {
-        if (logger.isTraceEnabled) {
-            Log.log(logger::trace, "fireDocumentInfoRemoved: for {}", file)
-        }
+        Log.trace(logger, project, "fireDocumentInfoRemoved: for {}", file)
         project.messageBus.syncPublisher(DocumentInfoChanged.DOCUMENT_INFO_CHANGED_TOPIC).documentInfoRemoved(file)
     }
 

ide-common/src/main/kotlin/org/digma/intellij/plugin/document/EditorDocumentService.kt

@@ -97,7 +97,7 @@ class EditorDocumentService(private val project: Project, private val cs: Corout
         try {
             doOnFileOpened(file)
         } catch (e: Throwable) {
-            Log.warnWithException(logger, e, "Exception in fileOpened {}", e)
+            Log.warnWithException(logger, project, e, "Exception in fileOpened {}", e)
             ErrorReporter.getInstance().reportError(project, "EditorDocumentService.fileOpened", e)
         }
     }
@@ -114,10 +114,7 @@ class EditorDocumentService(private val project: Project, private val cs: Corout
         //Note: I tried to use EditorFactory.getInstance().eventMulticaster but it will fire hundreds of events for every file open file also for non-writable
         // files. Don't use it!
         if (isRelevantLanguageFileNoSlowOperations(file)) {
-
-            if (logger.isTraceEnabled) {
-                Log.log(logger::trace, "fileOpened: processing {}", file)
-            }
+            Log.trace(logger, project, "fileOpened: processing {}", file)
 
             //this is protection against dev error, it should never happen. we should catch it in development.
             if (documentChangeListenerDisposables.contains(file)) {
@@ -127,20 +124,14 @@ class EditorDocumentService(private val project: Project, private val cs: Corout
 
             val document = FileDocumentManager.getInstance().getDocument(file)
             if (document != null) {
-                if (logger.isTraceEnabled) {
-                    Log.log(logger::trace, "fileOpened: adding document listener for {}", file)
-                }
+                Log.trace(logger, project, "fileOpened: adding document listener for {}", file)
                 val disposable = Disposer.newDisposable()
                 document.addDocumentListener(myDocumentListener, disposable)
                 documentChangeListenerDisposables[file] = disposable
-                if (logger.isTraceEnabled) {
-                    Log.log(logger::trace, "fileOpened: starting build document info job for {}", file)
-                }
+                Log.trace(logger, project, "fileOpened: starting build document info job for {}", file)
                 launchBuildDocumentInfoJob(file)
             } else {
-                if (logger.isTraceEnabled) {
-                    Log.log(logger::warn, "fileOpened: file is relevant but document is null for {}", file)
-                }
+                Log.warn(logger, project, "fileOpened: file is relevant but document is null for {}", file)
             }
         }
     }
@@ -150,7 +141,7 @@ class EditorDocumentService(private val project: Project, private val cs: Corout
         try {
             doOnFileClosed(file)
         } catch (e: Throwable) {
-            Log.warnWithException(logger, e, "Exception in fileClosed {}", e)
+            Log.warnWithException(logger, project, e, "Exception in fileClosed {}", e)
             ErrorReporter.getInstance().reportError(project, "EditorDocumentService.fileClosed", e)
         }
     }
@@ -168,15 +159,11 @@ class EditorDocumentService(private val project: Project, private val cs: Corout
             return
         }
 
-        if (logger.isTraceEnabled) {
-            Log.log(logger::trace, "fileClosed: processing {}", file)
-        }
+        Log.trace(logger, project, "fileClosed: processing {}", file)
 
         val disposable = documentChangeListenerDisposables.remove(file)
         disposable?.let {
-            if (logger.isTraceEnabled) {
-                Log.log(logger::trace, "fileClosed: removing document listener for {}", file)
-            }
+            Log.trace(logger, project, "fileClosed: removing document listener for {}", file)
             Disposer.dispose(it)
         }
 
@@ -186,7 +173,7 @@ class EditorDocumentService(private val project: Project, private val cs: Corout
                 removeDocumentFromChangedDocuments(file)
                 filesToUpdate.remove(file)
                 runningJobs[file]?.cancel(CancellationException("File was closed"))
-            }finally {
+            } finally {
                 putRemoveLock.withLock {
                     DocumentInfoStorage.getInstance(project).removeDocumentInfo(file)
                 }
@@ -220,8 +207,8 @@ class EditorDocumentService(private val project: Project, private val cs: Corout
         while (document != null) {
             if (document.isWritable) {
                 val file = FileDocumentManager.getInstance().getFile(document)
-                file?.let {
-                    filesToUpdate.add(file)
+                file?.takeIf { isValidVirtualFile(it) }?.let {
+                    filesToUpdate.add(it)
                 }
             }
             document = changedDocuments.poll()
@@ -241,20 +228,15 @@ class EditorDocumentService(private val project: Project, private val cs: Corout
     //This method is invoked after the quite period has passed.
     //While waiting for quite period we didn't run anything on EDT or read access.
     private fun updateDocumentInfo(virtualFile: VirtualFile) {
-        if (logger.isTraceEnabled) {
-            Log.log(logger::trace, "updateDocumentInfo: {}", virtualFile)
-        }
-
+        Log.trace(logger, project, "updateDocumentInfo: {}", virtualFile)
         launchBuildDocumentInfoJob(virtualFile)
     }
 
 
     //this method will be called on EDT from fileOpened, and in a coroutine for updates, it should run fast and not take read access.
     private fun launchBuildDocumentInfoJob(file: VirtualFile) {
 
-        if (logger.isTraceEnabled) {
-            Log.log(logger::trace, "starting buildDocumentInfo job for {}", file)
-        }
+        Log.trace(logger, project, "starting buildDocumentInfo job for {}", file)
 
         runningJobs[file]?.cancel(CancellationException("New job started"))
         val job = cs.launchWithErrorReporting("EditorDocumentService.launchBuildDocumentInfoJob", logger) {
@@ -275,40 +257,40 @@ class EditorDocumentService(private val project: Project, private val cs: Corout
         // building DocumentInfo finished and just before putting it in the storage, that is handled by putRemoveLock.
         //Exceptions are caught in the coroutine exception handler and reported in invokeOnCompletion.
 
-        Log.log(logger::trace, "buildDocumentInfo: {}", file)
+        Log.trace(logger, project, "buildDocumentInfo: {}", file)
 
         val isRelevant = readAction {
             isRelevantFile(file)
         }
         coroutineContext.ensureActive()
         if (!isRelevant) {
-            Log.log(logger::trace, "buildDocumentInfo: file is not relevant {}", file)
+            Log.trace(logger, project, "buildDocumentInfo: file is not relevant {}", file)
             return
         }
 
         if (!isSupportedLanguageFile(project, file)) {
-            Log.log(logger::trace, "buildDocumentInfo: file is not a supported language {}", file)
+            Log.trace(logger, project, "buildDocumentInfo: file is not a supported language {}", file)
             return
         }
         coroutineContext.ensureActive()
 
         val languageService = LanguageServiceProvider.getInstance(project).getLanguageService(file)
         if (languageService == null) {
-            Log.log(logger::warn, "buildDocumentInfo: could not find language service for {}", file)
+            Log.warn(logger, project, "buildDocumentInfo: could not find language service for {}", file)
             return
         }
 
         if (!languageService.isSupportedFile(file)) {
-            Log.log(logger::trace, "buildDocumentInfo: file is not supported by language service {}", file)
+            Log.trace(logger, project, "buildDocumentInfo: file is not supported by language service {}", file)
             return
         }
 
         coroutineContext.ensureActive()
         val documentInfo = languageService.buildDocumentInfo(file)
         if (documentInfo == null) {
-            Log.log(logger::warn, "buildDocumentInfo: could not build document info for {}", file)
+            Log.warn(logger, project, "buildDocumentInfo: could not build document info for {}", file)
         } else {
-            Log.log(logger::trace, "buildDocumentInfo: done building document info for {}", file)
+            Log.trace(logger, project, "buildDocumentInfo: done building document info for {}", file)
             coroutineContext.ensureActive()
             putRemoveLock.withLock {
                 coroutineContext.ensureActive()

ide-common/src/main/kotlin/org/digma/intellij/plugin/document/EditorEventsHandler.kt

@@ -1,6 +1,6 @@
 package org.digma.intellij.plugin.document
 
-import com.intellij.openapi.diagnostic.Logger
+import com.intellij.openapi.diagnostic.thisLogger
 import com.intellij.openapi.fileEditor.FileEditorManager
 import com.intellij.openapi.fileEditor.FileEditorManagerListener
 import com.intellij.openapi.project.Project
@@ -11,14 +11,11 @@ import org.digma.intellij.plugin.log.Log
 
 class EditorEventsHandler(private val project: Project) : FileEditorManagerListener {
 
-    private val logger = Logger.getInstance(this::class.java)
-
+    private val logger = thisLogger()
 
     override fun fileOpened(source: FileEditorManager, file: VirtualFile) {
         try {
-            if (logger.isTraceEnabled) {
-                Log.log(logger::trace, "fileOpened: {}", file)
-            }
+            Log.trace(logger, project, "fileOpened: {}", file)
 
             if (!isProjectValid(project)) {
                 return
@@ -27,17 +24,15 @@ class EditorEventsHandler(private val project: Project) : FileEditorManagerListe
             EditorDocumentService.getInstance(project).fileOpened(file)
 
         } catch (e: Throwable) {
-            Log.warnWithException(logger, e, "Exception in fileOpened {}", e)
+            Log.warnWithException(logger, project, e, "Exception in fileOpened {}", e)
             ErrorReporter.getInstance().reportError(project, "EditorEventsHandler.fileOpened", e)
         }
     }
 
     override fun fileClosed(source: FileEditorManager, file: VirtualFile) {
         try {
 
-            if (logger.isTraceEnabled) {
-                Log.log(logger::trace, "fileClosed: {}", file)
-            }
+            Log.trace(logger, project, "fileClosed: {}", file)
 
             if (!isProjectValid(project)) {
                 return
@@ -46,7 +41,7 @@ class EditorEventsHandler(private val project: Project) : FileEditorManagerListe
             EditorDocumentService.getInstance(project).fileClosed(file)
 
         } catch (e: Throwable) {
-            Log.warnWithException(logger, e, "Exception in fileClosed {}", e)
+            Log.warnWithException(logger, project, e, "Exception in fileClosed {}", e)
             ErrorReporter.getInstance().reportError(project, "EditorEventsHandler.fileClosed", e)
         }
     }
@@ -60,7 +55,7 @@ class EditorEventsHandler(private val project: Project) : FileEditorManagerListe
 //        try {
 //
 //            if (logger.isTraceEnabled) {
-//                Log.log(logger::trace, "selectionChanged: new {}", event.newFile)
+//                Log.trace(logger,project, "selectionChanged: new {}", event.newFile)
 //            }
 //
 //            if (!isProjectValid(project)) {
@@ -83,7 +78,7 @@ class EditorEventsHandler(private val project: Project) : FileEditorManagerListe
 //            EditorDocumentService.getInstance(project).fileOpened(file, editor)
 //
 //        } catch (e: Throwable) {
-//            Log.warnWithException(logger, e, "Exception in selectionChanged {}", e)
+//            Log.warnWithException(logger,project, e, "Exception in selectionChanged {}", e)
 //            ErrorReporter.getInstance().reportError(project, "EditorEventsHandler.selectionChanged", e)
 //        }
 //    }

ide-common/src/main/kotlin/org/digma/intellij/plugin/document/EditorUtils.kt

@@ -6,10 +6,14 @@ import com.intellij.openapi.fileEditor.TextEditor
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.vfs.VirtualFile
 import org.digma.intellij.plugin.common.EDT
+import org.digma.intellij.plugin.common.isValidVirtualFile
 
 //must be called on EDT
 fun getSelectedTextEditorForFile(project: Project, virtualFile: VirtualFile, fileEditorManager: FileEditorManager? = null): Editor? {
     EDT.assertIsDispatchThread()
+    if(!isValidVirtualFile(virtualFile)){
+        return null
+    }
     val editorManager = fileEditorManager ?: FileEditorManager.getInstance(project)
     val selectedEditor = editorManager.getSelectedEditor(virtualFile)
     return selectedEditor?.takeIf { it is TextEditor }?.let { (it as TextEditor).editor }