lsp-smithy integration (#50)

* Add smithyLsp module

* Migrate to lsp-smithy

* Scalafix, fmt + test

* Cleanup

* Small refactor to use more Resource

---------

Co-authored-by: Jakub Kozłowski <kubukoz@gmail.com>

Author: rochala

.mill-version

@@ -1 +1 @@
-0.12.10
+0.12.11

build.mill

@@ -1,12 +1,20 @@
+import mill.eval.Evaluator
+import smithy4s.codegen.LSP
 import com.goyeau.mill.scalafix.ScalafixModule
+import scala.collection.immutable.ListSet
 import coursier.core.Repository
 import coursier.maven.MavenRepository
 import mill._
 import mill.define.Sources
 import scalalib._
+import smithy4s.codegen.mill._
 
+import $ivy.`com.disneystreaming.smithy4s::smithy4s-mill-codegen-plugin_mill0.12:0.18.37`
 import $ivy.`com.goyeau::mill-scalafix::0.5.0`
 
+val jsonrpcVersion     = "0.1.0"
+val smithyVersion      = "1.57.1"
+
 trait CommonScalaModule extends ScalaModule with ScalafixModule {
   override def repositoriesTask: Task[Seq[Repository]] = T.task {
     Seq(
@@ -16,28 +24,39 @@ trait CommonScalaModule extends ScalaModule with ScalafixModule {
     ) ++ super.repositoriesTask()
   }
 
-  def scalaVersion = "3.7.0"
+  def scalaVersion = "3.7.2-RC1-bin-20250616-61d9887-NIGHTLY"
   def scalacOptions = Seq("-no-indent", "-Wunused:all")
 }
 
+object slsSmithy extends CommonScalaModule with Smithy4sModule {
+
+  override def ivyDeps = Agg(
+    ivy"com.disneystreaming.smithy4s::smithy4s-core:${smithy4sVersion()}",
+    ivy"tech.neander:jsonrpclib-smithy:$jsonrpcVersion",
+    ivy"io.github.simple-scala-tooling:lsp-smithy-definitions:1f4b6e9",
+  )
+}
+
 object sls extends CommonScalaModule {
 
   def mainClass = Some("org.scala.abusers.sls.SimpleScalaServer")
 
+  def moduleDeps: Seq[JavaModule] = Seq(slsSmithy)
+
   def ivyDeps = Agg(
-    ivy"com.github.plokhotnyuk.jsoniter-scala:jsoniter-scala-core_2.13:2.35.2".forceVersion(),
+    ivy"org.typelevel::cats-effect:3.6.2",
     ivy"co.fs2::fs2-io:3.13.0-M2",
-    ivy"tech.neander::jsonrpclib-fs2::0.0.8+26-13de833b-SNAPSHOT".forceVersion(),
+    ivy"io.scalaland::chimney:1.8.1",
+    ivy"io.scalaland::chimney-java-collections:1.8.1",
+    ivy"tech.neander::jsonrpclib-fs2::$jsonrpcVersion",
     ivy"ch.qos.logback:logback-classic:1.4.14",
-    ivy"tech.neander::langoustine-app::0.0.22",
     ivy"com.lihaoyi::os-lib:0.11.4",
-    ivy"org.polyvariant.smithy4s-bsp::bsp4s:0.4.1",
-    ivy"org.scalameta:mtags-interfaces:1.5.1:",
+    ivy"org.polyvariant.smithy4s-bsp::bsp4s:0.5.0",
+    ivy"org.scalameta:mtags-interfaces:1.5.1",
     ivy"com.evolution::scache:5.1.2",
     ivy"org.typelevel::cats-parse:1.1.0",
-    ivy"io.get-coursier:coursier_2.13:2.1.24"
-      .excludeOrg("org.scala-lang"),
-  ).map(_.exclude("com.github.plokhotnyuk.jsoniter-scala" -> "jsoniter-scala-core_3"))
+    ivy"io.get-coursier:interface:1.0.28"
+  )
 
   object test extends ScalaTests {
     def ivyDeps = Agg(

sls/src/org/scala/abusers/sls/BspClient.scala

@@ -14,10 +14,8 @@ import cats.syntax.all.*
 import com.comcast.ip4s.*
 import fs2.io.*
 import fs2.io.net.Network
-import jsonrpclib.fs2.*
 import jsonrpclib.Endpoint
-import langoustine.lsp.requests.window
-import langoustine.lsp.Communicate
+import jsonrpclib.fs2.{lsp => jsonrpclibLsp, *}
 import smithy4sbsp.bsp4s.BSPCodecs
 
 def makeBspClient(path: String, channel: FS2Channel[IO], report: String => IO[Unit]): Resource[IO, BuildServer] =
@@ -27,52 +25,53 @@ def makeBspClient(path: String, channel: FS2Channel[IO], report: String => IO[Un
       fs2.Stream
         .eval(IO.never)
         .concurrently(
-          socket.reads.through(lsp.decodeMessages).evalTap(m => report(m.toString)).through(channel.inputOrBounce)
+          socket.reads.through(jsonrpclibLsp.decodeMessages).evalTap(m => report(m.toString)).through(channel.inputOrBounce)
         )
-        .concurrently(channel.output.through(lsp.encodeMessages).through(socket.writes))
+        .concurrently(channel.output.through(jsonrpclibLsp.encodeMessages).through(socket.writes))
         .compile
         .drain
         .guarantee(IO.consoleForIO.errorln("Terminating server"))
         .background
     }
     .as(
       BuildServer(
-        BSPCodecs.clientStub(bsp.BuildServer, channel),
-        BSPCodecs.clientStub(bsp.jvm.JvmBuildServer, channel),
-        BSPCodecs.clientStub(bsp.scala_.ScalaBuildServer, channel),
-        BSPCodecs.clientStub(bsp.java_.JavaBuildServer, channel),
+        BSPCodecs.clientStub(bsp.BuildServer, channel).toTry.get,
+        BSPCodecs.clientStub(bsp.jvm.JvmBuildServer, channel).toTry.get,
+        BSPCodecs.clientStub(bsp.scala_.ScalaBuildServer, channel).toTry.get,
+        BSPCodecs.clientStub(bsp.java_.JavaBuildServer, channel).toTry.get,
       )
     )
 
-def bspClientHandler(lspClient: Communicate[IO], diagnosticManager: DiagnosticManager): List[Endpoint[IO]] =
-  BSPCodecs.serverEndpoints(
-    new BuildClient[IO] {
-      private def notify(msg: String) =
-        lspClient.notification(
-          window.showMessage(
-            langoustine.lsp.structures
-              .ShowMessageParams(`type` = langoustine.lsp.enumerations.MessageType.Info, message = msg)
+def bspClientHandler(lspClient: SlsLanguageClient[IO], diagnosticManager: DiagnosticManager): List[Endpoint[IO]] =
+  BSPCodecs
+    .serverEndpoints(
+      new BuildClient[IO] {
+
+        private def notify(msg: String) =
+          lspClient.windowShowMessage(
+            lsp.ShowMessageParams(_type = lsp.MessageType.INFO, message = msg)
           )
-        )
 
-      def onBuildLogMessage(input: LogMessageParams): IO[Unit] = IO.unit
+        def onBuildLogMessage(input: LogMessageParams): IO[Unit] = IO.unit // we want some logging to file here
 
-      def onBuildPublishDiagnostics(input: PublishDiagnosticsParams): IO[Unit] =
-        notify(s"We've just got $input") >>
+        def onBuildPublishDiagnostics(input: PublishDiagnosticsParams): IO[Unit] =
+          // notify(s"We've just got $input") >>
           diagnosticManager.onBuildPublishDiagnostics(lspClient, input)
 
-      def onBuildShowMessage(input: ShowMessageParams): IO[Unit] = IO.unit
+        def onBuildShowMessage(input: ShowMessageParams): IO[Unit] = IO.unit
 
-      def onBuildTargetDidChange(input: DidChangeBuildTarget): IO[Unit] = IO.unit
+        def onBuildTargetDidChange(input: DidChangeBuildTarget): IO[Unit] = IO.unit
 
-      def onBuildTaskFinish(input: OnBuildTaskFinishInput): IO[Unit] = IO.unit
+        def onBuildTaskFinish(input: OnBuildTaskFinishInput): IO[Unit] = IO.unit
 
-      def onBuildTaskProgress(input: TaskProgressParams): IO[Unit] = IO.unit
+        def onBuildTaskProgress(input: TaskProgressParams): IO[Unit] = IO.unit
 
-      def onBuildTaskStart(input: OnBuildTaskStartInput): IO[Unit] = IO.unit
+        def onBuildTaskStart(input: OnBuildTaskStartInput): IO[Unit] = IO.unit
 
-      def onRunPrintStderr(input: PrintParams): IO[Unit] = IO.unit
+        def onRunPrintStderr(input: PrintParams): IO[Unit] = IO.unit
 
-      def onRunPrintStdout(input: PrintParams): IO[Unit] = IO.unit
-    }
-  )
+        def onRunPrintStdout(input: PrintParams): IO[Unit] = IO.unit
+      }
+    )
+    .toTry
+    .get

sls/src/org/scala/abusers/sls/BspStateManager.scala

@@ -8,10 +8,7 @@ import bsp.InverseSourcesParams
 import cats.effect.kernel.Ref
 import cats.effect.std.AtomicCell
 import cats.effect.IO
-import langoustine.lsp.*
-import langoustine.lsp.structures.*
 import org.scala.abusers.pc.ScalaVersion
-import org.scala.abusers.sls.NioConverter.asNio
 import org.scala.abusers.sls.LoggingUtils.*
 
 import java.net.URI
@@ -32,12 +29,12 @@ object ScalaBuildTargetInformation {
 
 object BspStateManager {
 
-  def instance(bspServer: BuildServer): IO[BspStateManager] =
+  def instance(lspClient: SlsLanguageClient[IO], bspServer: BuildServer): IO[BspStateManager] =
     // We should track this in progress bar. Think of this as `Import Build`
     for {
       sourcesToTargets <- AtomicCell[IO].of(Map[URI, ScalaBuildTargetInformation]())
       buildTargets     <- Ref.of[IO, Set[ScalaBuildTargetInformation]](Set.empty)
-    } yield BspStateManager(bspServer, sourcesToTargets, buildTargets)
+    } yield BspStateManager(lspClient, bspServer, sourcesToTargets, buildTargets)
 }
 
 /** Class responsible for tracking and handling map between file and target we want to compile it against
@@ -47,19 +44,20 @@ object BspStateManager {
   * feature Another option will be to default to latest version which after all I'll default to right now
   */
 class BspStateManager(
+    lspClient: SlsLanguageClient[IO],
     val bspServer: BuildServer,
     sourcesToTargets: AtomicCell[IO, Map[URI, ScalaBuildTargetInformation]],
     targets: Ref[IO, Set[ScalaBuildTargetInformation]],
 ) {
   import ScalaBuildTargetInformation.*
 
-  def importBuild(back: Communicate[IO]) =
+  def importBuild =
     for {
-      _ <- back.logMessage("Starting build import.") // in the future this should be a task with progress
+      _             <- lspClient.logMessage("Starting build import.") // in the future this should be a task with progress
       importedBuild <- getBuildInformation(bspServer)
       _ <- bspServer.generic.buildTargetCompile(CompileParams(targets = importedBuild.map(_.buildTarget.id).toList))
       _ <- targets.set(importedBuild)
-      _ <- back.logMessage("Build import finished.")
+      _ <- lspClient.logMessage("Build import finished.")
     } yield ()
 
   private val byScalaVersion: Ordering[ScalaBuildTargetInformation] = new Ordering[ScalaBuildTargetInformation] {
@@ -115,15 +113,15 @@ class BspStateManager(
       state.getOrElse(uri, throw new IllegalStateException("Get should always be called after didOpen"))
     }
 
-  def didOpen(in: Invocation[DidOpenTextDocumentParams, IO]): IO[Unit] = {
-    val uri = in.params.textDocument.uri.asNio
+  def didOpen(client: SlsLanguageClient[IO], params: lsp.DidOpenTextDocumentParams): IO[Unit] = {
+    val uri = URI.create(params.textDocument.uri)
     sourcesToTargets.evalUpdate(state =>
       for {
         possibleIds <- buildTargetInverseSources(uri)
         targets0    <- targets.get
         possibleBuildTargets = possibleIds.flatMap(id => targets0.find(_.buildTarget.id == id))
         bestBuildTarget      = possibleBuildTargets.maxBy(_.buildTarget.project.scala.map(_.data.scalaVersion))
-        _ <- in.toClient.logDebug(s"Best build target for $uri is ${bestBuildTarget.toString}")
+        _ <- client.logDebug(s"Best build target for $uri is ${bestBuildTarget.toString}")
       } yield state.updated(uri, bestBuildTarget)
     )
   }

sls/src/org/scala/abusers/sls/Debouncer.scala

@@ -1,13 +1,12 @@
 package org.scala.abusers.sls
 
-import scala.concurrent.duration.FiniteDuration
-import cats.effect.Temporal
-import cats.effect.Ref
 import cats.effect.kernel.Fiber
-import cats.effect.kernel.Sync
 import cats.effect.IO
+import cats.effect.Ref
+import cats.effect.Temporal
 import cats.syntax.all.*
 
+import scala.concurrent.duration.FiniteDuration
 
 class Debouncer(delay: FiniteDuration) {
 
@@ -20,7 +19,7 @@ class Debouncer(delay: FiniteDuration) {
       fiber <- Temporal[IO].start(
         IO.sleep(delay) *> run
       )
-      _        <- ref.set(Some(fiber))
+      _ <- ref.set(Some(fiber))
     } yield ()
 
 }

sls/src/org/scala/abusers/sls/DiagnosticManager.scala

@@ -5,65 +5,59 @@ import bsp.PublishDiagnosticsParams as BspPublishDiagnosticsParams
 import cats.effect.std.MapRef
 import cats.effect.IO
 import cats.syntax.all.*
-import langoustine.lsp
-import langoustine.lsp.requests.textDocument.publishDiagnostics
-import langoustine.lsp.runtime.*
-import langoustine.lsp.structures.Diagnostic as LspDiagnostic
-import langoustine.lsp.structures.DidChangeTextDocumentParams
-import langoustine.lsp.structures.PublishDiagnosticsParams as LspPublishDiagnosticsParams
-import langoustine.lsp.Communicate
-import langoustine.lsp.Invocation
-import org.scala.abusers.sls.NioConverter.*
 import smithy4s.json.Json
 
-import java.net.URI
-
 /** Diagnostic State Manager
   *
   * This class is reposnobile for holding the state of the diagnostic displayed on the client
   *
   * Proposed heuristic is: On file save we trigger compilation, and this results in notifications being sent from BSP
-  * server. We will keep adding diagnostics, and will clean them only when [[PublishDiagnosticsParams.reset]] is
-  * set to true.
+  * server. We will keep adding diagnostics, and will clean them only when [[PublishDiagnosticsParams.reset]] is set to
+  * true.
   *
   * @param publishedDiagnostics
   */
-class DiagnosticManager(publishedDiagnostics: MapRef[IO, URI, Option[Set[LspDiagnostic]]]) {
-  private def convertDiagnostic(bspDiag: BspDiagnostic): LspDiagnostic = {
+// FIXME revert this to URI
+class DiagnosticManager(publishedDiagnostics: MapRef[IO, String, Option[Set[lsp.Diagnostic]]]) {
+  private def convertDiagnostic(bspDiag: BspDiagnostic): lsp.Diagnostic = {
     val data = Json.writeBlob(bspDiag)
-    upickle.default.read[LspDiagnostic](data.asByteBuffer)
+    // to be chimneyed
+    Json.read[lsp.Diagnostic](data).toOption.getOrElse(sys.error(s"Failed to convert BSP diagnostic to LSP: $data"))
   }
 
-  def didChange(in: Invocation[DidChangeTextDocumentParams, IO], pcDiags: Vector[LspDiagnostic]): IO[Unit] =
+  def didChange(client: SlsLanguageClient[IO], uri: String, pcDiags: List[lsp.Diagnostic]): IO[Unit] =
     // remove diagnostic on modified lines
     // ask presentation compiler for diagnostics
     for {
-      _ <- publishedDiagnostics(in.params.textDocument.uri.asNio).set(pcDiags.toSet.some)
-      request = LspPublishDiagnosticsParams(in.params.textDocument.uri, Opt.empty, pcDiags.toVector)
-      _ <- in.toClient.notification(publishDiagnostics(request))
+      _ <- publishedDiagnostics(uri).set(pcDiags.toSet.some)
+      request = lsp.PublishDiagnosticsParams(uri, pcDiags, None)
+      _ <- client.textDocumentPublishDiagnostics(request)
     } yield ()
 
-  def onBuildPublishDiagnostics(lspClient: Communicate[IO], input: BspPublishDiagnosticsParams): IO[Unit] = {
+  def onBuildPublishDiagnostics(client: SlsLanguageClient[IO], input: BspPublishDiagnosticsParams): IO[Unit] = {
     val bspUri   = input.textDocument.uri
     val lspDiags = input.diagnostics.toSet.map(convertDiagnostic)
-    def request(diags: Set[LspDiagnostic]) =
-      LspPublishDiagnosticsParams(DocumentUri(bspUri.value), Opt.empty, diags.toVector)
+    def request(diags: Set[lsp.Diagnostic]) =
+      lsp.PublishDiagnosticsParams(bspUri.value, diags.toList, None)
+
     if input.reset then {
       for {
-        _ <- publishedDiagnostics(input.textDocument.uri.asNio).set(lspDiags.some)
-        _ <- lspClient.notification(publishDiagnostics(request(lspDiags)))
+        _ <- publishedDiagnostics(input.textDocument.uri.value).set(lspDiags.some)
+        _ <- client.textDocumentPublishDiagnostics(
+          lsp.PublishDiagnosticsParams(input.textDocument.uri.value, lspDiags.toList)
+        )
       } yield ()
 
     } else {
       for {
-        currentDiags <- publishedDiagnostics(bspUri.asNio).updateAndGet(_.foldLeft(lspDiags)(_ ++ _).some)
-        _            <- lspClient.notification(publishDiagnostics(request(currentDiags.get)))
+        currentDiags <- publishedDiagnostics(bspUri.value).updateAndGet(_.foldLeft(lspDiags)(_ ++ _).some)
+        _            <- client.textDocumentPublishDiagnostics(request(currentDiags.get))
       } yield ()
     }
   }
 }
 
 object DiagnosticManager {
   def instance: IO[DiagnosticManager] =
-    MapRef.ofScalaConcurrentTrieMap[IO, URI, Set[LspDiagnostic]].map(DiagnosticManager.apply)
+    MapRef.ofScalaConcurrentTrieMap[IO, String, Set[lsp.Diagnostic]].map(DiagnosticManager.apply)
 }

sls/src/org/scala/abusers/sls/LoggingUtils.scala

@@ -1,29 +1,16 @@
 package org.scala.abusers.sls
 
 import cats.effect.IO
-import langoustine.lsp.*
-import langoustine.lsp.structures.LogMessageParams
-import langoustine.lsp.structures.ShowMessageParams
-import langoustine.lsp.Communicate
 
 object LoggingUtils {
-  extension (back: Communicate[IO]) {
+  extension (client: SlsLanguageClient[IO]) {
     def sendMessage(msg: String): IO[Unit] =
-      back.notification(
-        requests.window.showMessage,
-        ShowMessageParams(enumerations.MessageType.Info, msg),
-      ) *> logMessage(msg)
+      client.windowShowMessage(lsp.ShowMessageParams(lsp.MessageType.INFO, msg)) *> logMessage(msg)
 
-    def logMessage(message: String): IO[Unit] =
-      back.notification(
-        requests.window.logMessage,
-        LogMessageParams(enumerations.MessageType.Info, message),
-      )
+    def logMessage(msg: String): IO[Unit] =
+      client.windowLogMessage(lsp.LogMessageParams(lsp.MessageType.INFO, msg))
 
-    def logDebug(message: String): IO[Unit] =
-      back.notification(
-        requests.window.logMessage,
-        LogMessageParams(enumerations.MessageType.Debug, message),
-      )
+    def logDebug(msg: String): IO[Unit] =
+      client.windowLogMessage(lsp.LogMessageParams(lsp.MessageType.LOG, msg))
   }
 }

sls/src/org/scala/abusers/sls/NioConverter.scala

@@ -1,11 +1,8 @@
 package org.scala.abusers.sls
 
-import langoustine.lsp.runtime.DocumentUri
-
 import java.net.URI
 import scala.annotation.targetName
 
 object NioConverter {
-  extension (documentUri: DocumentUri) @targetName("lspAsNio") def asNio: URI = URI.create(documentUri.value)
-  extension (uri: bsp.URI) @targetName("bspAsNio") def asNio: URI             = URI.create(uri.value)
+  extension (uri: bsp.URI) @targetName("bspAsNio") def asNio: URI = URI.create(uri.value)
 }