LSP API

The LSP API provides interfaces for implementing Language Server Protocol features in Android Code Studio, enabling code completion, navigation, diagnostics, and more.

Core Interfaces

ILanguageServer

The main interface for implementing language server functionality. Source: core/lsp-api/src/main/java/com/tom/rv2ide/lsp/api/ILanguageServer.kt:57

package com.tom.rv2ide.lsp.api

import com.tom.rv2ide.lsp.models.*
import com.tom.rv2ide.models.Range
import com.tom.rv2ide.projects.IWorkspace
import java.nio.file.Path

interface ILanguageServer {
  
  // Server identity
  val serverId: String?
  val client: ILanguageClient?
  
  // Lifecycle
  fun shutdown()
  fun connectClient(client: ILanguageClient?)
  fun applySettings(settings: IServerSettings?)
  fun setupWorkspace(workspace: IWorkspace)
  
  // Code completion
  fun complete(params: CompletionParams?): CompletionResult
  
  // Code navigation
  suspend fun findReferences(params: ReferenceParams): ReferenceResult
  suspend fun findDefinition(params: DefinitionParams): DefinitionResult
  suspend fun expandSelection(params: ExpandSelectionParams): Range
  
  // Documentation
  suspend fun signatureHelp(params: SignatureHelpParams): SignatureHelp
  suspend fun hover(params: DefinitionParams): MarkupContent
  
  // Diagnostics
  suspend fun analyze(file: Path): DiagnosticResult
  
  // Formatting
  fun formatCode(params: FormatCodeParams?): CodeFormatResult
  
  // Error handling
  fun handleFailure(failure: LSPFailure?): Boolean
}

ILanguageClient

Interface for receiving notifications from the language server. Source: core/lsp-api/src/main/java/com/tom/rv2ide/lsp/api/ILanguageClient.java

package com.tom.rv2ide.lsp.api;

import com.tom.rv2ide.lsp.models.DiagnosticResult;
import com.tom.rv2ide.lsp.models.ShowDocumentParams;
import java.nio.file.Path;

public interface ILanguageClient {
  
  // Diagnostics
  void publishDiagnostics(Path file, DiagnosticResult result);
  
  // Document operations
  void showDocument(ShowDocumentParams params);
  
  // Messages
  void logMessage(int type, String message);
  void showMessage(int type, String message);
}

Implementing a Language Server

Basic Server Implementation

Create a custom language server:

import com.tom.rv2ide.lsp.api.ILanguageServer
import com.tom.rv2ide.lsp.api.ILanguageClient
import com.tom.rv2ide.lsp.models.*
import com.tom.rv2ide.projects.IWorkspace
import java.nio.file.Path

class MyLanguageServer : ILanguageServer {
  
  override val serverId = "my-language-server"
  override var client: ILanguageClient? = null
  private var workspace: IWorkspace? = null
  
  override fun shutdown() {
    // Release resources
    workspace = null
    client = null
  }
  
  override fun connectClient(client: ILanguageClient?) {
    this.client = client
  }
  
  override fun applySettings(settings: IServerSettings?) {
    // Apply user preferences
  }
  
  override fun setupWorkspace(workspace: IWorkspace) {
    this.workspace = workspace
  }
  
  override fun complete(params: CompletionParams?): CompletionResult {
    // Implement code completion
    val items = mutableListOf<CompletionItem>()
    // ... populate completion items
    return CompletionResult(items)
  }
  
  override suspend fun findDefinition(params: DefinitionParams): DefinitionResult {
    // Implement go-to-definition
    // Return locations of definition
    return DefinitionResult.EMPTY
  }
  
  override suspend fun analyze(file: Path): DiagnosticResult {
    // Analyze file and return diagnostics
    val diagnostics = mutableListOf<DiagnosticItem>()
    // ... add errors, warnings, etc.
    return DiagnosticResult(diagnostics)
  }
  
  // Implement other methods...
}

Register Language Server

import com.tom.rv2ide.lsp.api.ILanguageServerRegistry

val registry = ILanguageServerRegistry.getDefault()
val myServer = MyLanguageServer()

// Register for specific file types
registry.register(myServer, listOf(".kt", ".java"))

Code Completion

Completion Parameters

Handle completion requests:

import com.tom.rv2ide.lsp.models.*
import com.tom.rv2ide.models.Position

override fun complete(params: CompletionParams?): CompletionResult {
  if (params == null) return CompletionResult.EMPTY
  
  val file = params.file
  val position = params.position  // Cursor position
  val prefix = params.prefix      // Text before cursor
  
  val items = mutableListOf<CompletionItem>()
  
  // Add keyword completions
  items.add(CompletionItem().apply {
    label = "class"
    detail = "Keyword"
    kind = CompletionItemKind.Keyword
    insertText = "class "
  })
  
  // Add method completions
  items.add(CompletionItem().apply {
    label = "toString()"
    detail = "String"
    kind = CompletionItemKind.Method
    insertText = "toString()"
  })
  
  return CompletionResult(items)
}

params.file

Path

The file being edited

params.position

Position

The cursor position where completion was triggered

params.prefix

String

The text before the cursor on the current line

Completion Items

Create rich completion items:

val item = CompletionItem().apply {
  label = "myMethod"                    // Display text
  detail = "void myMethod(String arg)"  // Type/signature
  documentation = "Does something"      // Description
  kind = CompletionItemKind.Method
  insertText = "myMethod($1)$0"        // Snippet with placeholders
  sortText = "0000"                     // Sort priority
  filterText = "myMethod"               // Text to match against
}

Go to Definition

Implement definition lookup:

import com.tom.rv2ide.lsp.models.*
import com.tom.rv2ide.models.*

override suspend fun findDefinition(params: DefinitionParams): DefinitionResult {
  val file = params.file
  val position = params.position
  
  // Find the symbol at position
  val symbol = findSymbolAt(file, position)
  
  if (symbol != null) {
    // Return definition location
    val location = Location().apply {
      this.file = symbol.definitionFile
      this.range = Range(
        Position(symbol.line, symbol.column),
        Position(symbol.line, symbol.column + symbol.name.length)
      )
    }
    return DefinitionResult(listOf(location))
  }
  
  return DefinitionResult.EMPTY
}

Find References

Find all references to a symbol:

override suspend fun findReferences(params: ReferenceParams): ReferenceResult {
  val file = params.file
  val position = params.position
  val includeDeclaration = params.includeDeclaration
  
  val locations = mutableListOf<Location>()
  
  // Search for references across the workspace
  workspace?.getSubProjects()?.forEach { project ->
    // Search in project files
    val refs = searchReferences(project, file, position)
    locations.addAll(refs)
  }
  
  return ReferenceResult(locations)
}

Diagnostics

Analyze Files

Perform analysis and report issues:

import com.tom.rv2ide.lsp.models.*
import java.nio.file.Path

override suspend fun analyze(file: Path): DiagnosticResult {
  val diagnostics = mutableListOf<DiagnosticItem>()
  
  // Parse and analyze file
  val errors = analyzeFile(file)
  
  errors.forEach { error ->
    diagnostics.add(DiagnosticItem().apply {
      range = error.range
      severity = DiagnosticSeverity.ERROR
      message = error.message
      source = "my-language-server"
    })
  }
  
  return DiagnosticResult(diagnostics)
}

Publish Diagnostics

Send diagnostics to the client:

fun analyzeAndPublish(file: Path) {
  val result = analyze(file)
  client?.publishDiagnostics(file, result)
}

DiagnosticResult

object

diagnostics

List<DiagnosticItem>

List of diagnostic items (errors, warnings, info)

Diagnostic Severity

enum class DiagnosticSeverity {
  ERROR,    // Red error
  WARNING,  // Yellow warning
  INFO,     // Blue information
  HINT      // Suggestion
}

Signature Help

Parameter Hints

Provide parameter information:

import com.tom.rv2ide.lsp.models.*

override suspend fun signatureHelp(params: SignatureHelpParams): SignatureHelp {
  val file = params.file
  val position = params.position
  
  // Find function call at position
  val call = findFunctionCall(file, position)
  
  if (call != null) {
    val signature = SignatureInformation().apply {
      label = "myFunction(arg1: String, arg2: Int)"
      documentation = "Performs an operation"
      parameters = listOf(
        ParameterInformation("arg1", "The first argument"),
        ParameterInformation("arg2", "The second argument")
      )
    }
    
    return SignatureHelp().apply {
      signatures = listOf(signature)
      activeSignature = 0
      activeParameter = call.currentParameter
    }
  }
  
  return SignatureHelp.EMPTY
}

Code Formatting

Format Code

Implement code formatting:

import com.tom.rv2ide.lsp.models.*

override fun formatCode(params: FormatCodeParams?): CodeFormatResult {
  if (params == null) return CodeFormatResult(false, emptyList())
  
  val content = params.content
  val edits = mutableListOf<TextEdit>()
  
  // Format the code
  val formatted = formatSource(content)
  
  // Create text edit for entire document
  edits.add(TextEdit().apply {
    range = Range(
      Position(0, 0),
      Position(content.lines().size, 0)
    )
    newText = formatted
  })
  
  return CodeFormatResult(true, edits)
}

Hover Documentation

Show Documentation

Provide hover information:

override suspend fun hover(params: DefinitionParams): MarkupContent {
  val file = params.file
  val position = params.position
  
  val symbol = findSymbolAt(file, position)
  
  if (symbol != null) {
    return MarkupContent().apply {
      kind = MarkupKind.MARKDOWN
      value = """
        ### ${symbol.name}
        
        **Type:** ${symbol.type}
        
        ${symbol.documentation}
        
        ```java
        ${symbol.signature}

""".trimIndent() } } return MarkupContent() }

## Complete Example

Here's a complete language server implementation:

```kotlin
import com.tom.rv2ide.lsp.api.*
import com.tom.rv2ide.lsp.models.*
import com.tom.rv2ide.models.*
import com.tom.rv2ide.projects.IWorkspace
import java.nio.file.Path

class KotlinLanguageServer : ILanguageServer {
  
  override val serverId = "kotlin-language-server"
  override var client: ILanguageClient? = null
  private var workspace: IWorkspace? = null
  private val analyzer = KotlinAnalyzer()
  
  override fun shutdown() {
    analyzer.shutdown()
    workspace = null
    client = null
  }
  
  override fun connectClient(client: ILanguageClient?) {
    this.client = client
    client?.logMessage(1, "Kotlin language server connected")
  }
  
  override fun setupWorkspace(workspace: IWorkspace) {
    this.workspace = workspace
    analyzer.indexWorkspace(workspace)
  }
  
  override fun applySettings(settings: IServerSettings?) {
    // Apply settings
  }
  
  override fun complete(params: CompletionParams?): CompletionResult {
    if (params == null) return CompletionResult.EMPTY
    
    return analyzer.complete(
      params.file,
      params.position,
      params.prefix
    )
  }
  
  override suspend fun findDefinition(params: DefinitionParams): DefinitionResult {
    return analyzer.findDefinition(params.file, params.position)
  }
  
  override suspend fun findReferences(params: ReferenceParams): ReferenceResult {
    return analyzer.findReferences(
      params.file,
      params.position,
      params.includeDeclaration
    )
  }
  
  override suspend fun signatureHelp(params: SignatureHelpParams): SignatureHelp {
    return analyzer.getSignatureHelp(params.file, params.position)
  }
  
  override suspend fun analyze(file: Path): DiagnosticResult {
    val result = analyzer.analyze(file)
    client?.publishDiagnostics(file, result)
    return result
  }
  
  override suspend fun expandSelection(params: ExpandSelectionParams): Range {
    return analyzer.expandSelection(params.file, params.range)
  }
  
  override fun formatCode(params: FormatCodeParams?): CodeFormatResult {
    if (params == null) return CodeFormatResult(false, emptyList())
    return analyzer.format(params.content)
  }
  
  override fun handleFailure(failure: LSPFailure?): Boolean {
    if (failure != null) {
      client?.logMessage(3, "LSP Error: ${failure.message}")
      return true
    }
    return false
  }
}

Editor API

Integrate LSP with editors

Project API

Access workspace information

Overview

Core APIs

Extension Development

Core Interfaces

ILanguageServer

ILanguageClient

Implementing a Language Server

Basic Server Implementation

Register Language Server

Code Completion

Completion Parameters

Completion Items

Code Navigation

Go to Definition

Find References

Diagnostics

Analyze Files

Publish Diagnostics

Diagnostic Severity

Signature Help

Parameter Hints

Code Formatting

Format Code

Hover Documentation

Show Documentation

Editor API

Project API

Overview

Core APIs

Extension Development

Documentation Index

​Core Interfaces

​ILanguageServer

​ILanguageClient

​Implementing a Language Server

​Basic Server Implementation

​Register Language Server

​Code Completion

​Completion Parameters

​Completion Items

​Code Navigation

​Go to Definition

​Find References

​Diagnostics

​Analyze Files

​Publish Diagnostics

​Diagnostic Severity

​Signature Help

​Parameter Hints

​Code Formatting

​Format Code

​Hover Documentation

​Show Documentation

​Related APIs

Editor API

Project API

Core Interfaces

ILanguageServer

ILanguageClient

Implementing a Language Server

Basic Server Implementation

Register Language Server

Code Completion

Completion Parameters

Completion Items

Code Navigation

Go to Definition

Find References

Diagnostics

Analyze Files

Publish Diagnostics

Diagnostic Severity

Signature Help

Parameter Hints

Code Formatting

Format Code

Hover Documentation

Show Documentation

Related APIs