Merge pull request #57 from gtache/1.5.1

1.5.1

intellij-lsp/build.gradle

@@ -14,6 +14,10 @@ intellij {
     pluginName 'LSP Support'
 }
 
+patchPluginXml {
+    untilBuild '2018.3'
+}
+
 dependencies {
     compile group: 'org.eclipse.lsp4j', name: 'org.eclipse.lsp4j', version: '0.6.0'
     compile group: 'io.get-coursier', name: 'coursier_2.12', version: '1.0.3'

intellij-lsp/resources/META-INF/plugin.xml

@@ -1,25 +1,16 @@
 <idea-plugin>
     <id>com.github.gtache.lsp</id>
     <name>LSP Support</name>
-    <version>1.5.0</version>
+    <version>1.5.1</version>
     <vendor email="[email protected]" url="https://github.com/gtache">gtache</vendor>
 
     <description>Adds LSP (Language Server Protocol) support for IntelliJ</description>
 
     <change-notes>
         <![CDATA[
-            -Updates to lsp4j 0.6.0
-            -Adds possibility to manually link files to a specific server
-            -Adds setting to always send requests
-            -Improves go to with ctrl-click
-            -Fixes Find Usages with ctrl-click
-            -Fixes exception when no references found
-            -Fixes exception when a position is bigger than the line length
-            -Fixes missing "Show reformat file dialog" and "Reformat code" texts in the menu
-            -Fixes closing an editor while server is starting not being registered
-            -Fixes mix of plain text and markup for hover being displayed incorrectly
-            -Better handling of opened editors at startup
-            -Potential fix for diagnostic highlights not being cleared
+            -Fixes error when using LinkToServer with shortcut
+            -Fixes missing diagnostics when codeAction is unavailable
+            -Fixes missing code completions
 ]]>
     </change-notes>
 

intellij-lsp/src/com/github/gtache/lsp/actions/LSPLinkToServerAction.scala

@@ -9,13 +9,16 @@ import com.github.gtache.lsp.settings.gui.ComboCheckboxDialog
 import com.github.gtache.lsp.utils.ApplicationUtils.computableWriteAction
 import com.github.gtache.lsp.utils.FileUtils
 import com.intellij.openapi.actionSystem.{ActionPlaces, AnActionEvent, CommonDataKeys}
+import com.intellij.openapi.diagnostic.Logger
 import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.fileEditor.{FileDocumentManager, FileEditorManager, OpenFileDescriptor}
 import com.intellij.openapi.project.{DumbAwareAction, Project}
 import com.intellij.openapi.ui.Messages
 import com.intellij.openapi.vfs.LocalFileSystem
 
 class LSPLinkToServerAction extends DumbAwareAction {
+  private val LOG: Logger = Logger.getInstance(classOf[LSPLinkToServerAction])
+
   override def actionPerformed(anActionEvent: AnActionEvent): Unit = {
     var editors: Array[Editor] = Array()
     val project: Project = anActionEvent.getDataContext.getData(CommonDataKeys.PROJECT)
@@ -32,6 +35,9 @@ class LSPLinkToServerAction extends DumbAwareAction {
       case ActionPlaces.PROJECT_VIEW_POPUP =>
         val virtualFiles = anActionEvent.getDataContext.getData(CommonDataKeys.VIRTUAL_FILE_ARRAY)
         editors = openClosedEditors(virtualFiles.map(v => FileUtils.VFSToURI(v)), project)
+      case _ =>
+        editors = Array(anActionEvent.getDataContext.getData(CommonDataKeys.EDITOR_EVEN_IF_INACTIVE))
+        LOG.warn("Unknown place : " + anActionEvent.getPlace)
     }
     val allEditors = editors.filter(e => e != null).partition(e => LanguageServerWrapperImpl.forEditor(e).isEmpty)
     editors = allEditors._1 ++ allEditors._2

intellij-lsp/src/com/github/gtache/lsp/client/LanguageClientImpl.scala

@@ -5,7 +5,7 @@ import java.util.concurrent.{CompletableFuture, FutureTask}
 
 import com.github.gtache.lsp.client.languageserver.wrapper.LanguageServerWrapper
 import com.github.gtache.lsp.editor.EditorEventManager
-import com.github.gtache.lsp.requests.{SemanticHighlightingHandler, WorkspaceEditHandler}
+import com.github.gtache.lsp.requests.WorkspaceEditHandler
 import com.github.gtache.lsp.utils.{ApplicationUtils, FileUtils}
 import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.diagnostic.Logger
@@ -107,8 +107,4 @@ class LanguageClientImpl extends LanguageClient {
         LOG.warn("Unknown message type for " + message)
     }
   }
-
-  override def semanticHighlighting(params: SemanticHighlightingParams): Unit = {
-    SemanticHighlightingHandler.handlePush(params)
-  }
 }

intellij-lsp/src/com/github/gtache/lsp/contributors/inspection/LSPInspection.scala

@@ -44,13 +44,13 @@ class LSPInspection extends LocalInspectionTool {
             }
             val element = LSPPsiElement(name, m.editor.getProject, start, end, file)
             val codeActionResult = m.codeAction(element)
-            if (codeActionResult != null) {
-              val (commandsE, codeActionsE) = codeActionResult.filter(e => e != null && (e.isLeft || e.isRight)).partition(e => e.isLeft)
-              val commands = commandsE.map(e => e.getLeft).map(c => new LSPCommandFix(uri, c))
-              val codeActions = codeActionsE.map(e => e.getRight).map(c => new LSPCodeActionFix(uri, c))
-              manager.createProblemDescriptor(element, null.asInstanceOf[TextRange], diagnostic.getMessage, severity, isOnTheFly,
-                (commands ++ codeActions).toArray: _*)
-            } else null
+            val fixes = if (codeActionResult != null) {
+                          val (commandsE, codeActionsE) = codeActionResult.filter(e => e != null && (e.isLeft || e.isRight)).partition(e => e.isLeft)
+                          val commands = commandsE.map(e => e.getLeft).map(c => new LSPCommandFix(uri, c))
+                          val codeActions = codeActionsE.map(e => e.getRight).map(c => new LSPCodeActionFix(uri, c))
+                          (commands ++ codeActions).toArray
+                        } else null
+            manager.createProblemDescriptor(element, null.asInstanceOf[TextRange], diagnostic.getMessage, severity, isOnTheFly, fixes: _*)
           } else null
         }.toArray.filter(d => d != null)
       }

intellij-lsp/src/com/github/gtache/lsp/editor/EditorEventManager.scala

@@ -316,33 +316,37 @@ class EditorEventManager(val editor: Editor, val mouseListener: EditorMouseListe
                     })*/
             if (textEdit != null) {
               if (addTextEdits != null) {
-                lookupElementBuilder = LookupElementBuilder.create("")
+                lookupElementBuilder = LookupElementBuilder.create(presentableText, "")
                   .withInsertHandler((context: InsertionContext, item: LookupElement) => {
                     context.commitDocument()
                     invokeLater(() => {
                       applyEdit(edits = addTextEdits.asScala :+ textEdit, name = "Completion : " + label)
                       if (command != null) executeCommands(Iterable(command))
                     })
                   })
+                  .withLookupString(presentableText)
               } else {
-                lookupElementBuilder = LookupElementBuilder.create("")
+                lookupElementBuilder = LookupElementBuilder.create(presentableText, "")
                   .withInsertHandler((context: InsertionContext, item: LookupElement) => {
                     context.commitDocument()
                     invokeLater(() => {
                       applyEdit(edits = Seq(textEdit), name = "Completion : " + label)
                       if (command != null) executeCommands(Iterable(command))
+                      editor.getCaretModel.moveCaretRelatively(textEdit.getNewText.length,0,false,false,true)
                     })
                   })
+                  .withLookupString(presentableText)
               }
             } else if (addTextEdits != null) {
-              lookupElementBuilder = LookupElementBuilder.create("")
+              lookupElementBuilder = LookupElementBuilder.create(presentableText, "")
                 .withInsertHandler((context: InsertionContext, item: LookupElement) => {
                   context.commitDocument()
                   invokeLater(() => {
                     applyEdit(edits = addTextEdits.asScala, name = "Completion : " + label)
                     if (command != null) executeCommands(Iterable(command))
                   })
                 })
+                .withLookupString(presentableText)
             } else {
               lookupElementBuilder = LookupElementBuilder.create(if (insertText != null && insertText != "") insertText else label)
               if (command != null) lookupElementBuilder = lookupElementBuilder.withInsertHandler((context: InsertionContext, item: LookupElement) => {