chore: update mtags to 1.5.1

Author: kasiaMarek

presentation-compiler/src/main/dotty/tools/pc/PcInlayHintsProvider.scala

@@ -57,7 +57,7 @@ class PcInlayHintsProvider(
       .headOption
       .getOrElse(unit.tpdTree)
       .enclosedChildren(pos.span)
-      .flatMap(tpdTree => deepFolder(InlayHints.empty, tpdTree).result())
+      .flatMap(tpdTree => deepFolder(InlayHints.empty(params.uri()), tpdTree).result())
 
   private def adjustPos(pos: SourcePosition): SourcePosition =
     pos.adjust(text)._1

presentation-compiler/src/main/dotty/tools/pc/ScalaPresentationCompiler.scala

@@ -16,6 +16,7 @@ import scala.language.unsafeNulls
 import scala.meta.internal.metals.CompilerVirtualFileParams
 import scala.meta.internal.metals.EmptyCancelToken
 import scala.meta.internal.metals.EmptyReportContext
+import scala.meta.internal.metals.PcQueryContext
 import scala.meta.internal.metals.ReportContext
 import scala.meta.internal.metals.ReportLevel
 import scala.meta.internal.metals.StdReportContext
@@ -143,26 +144,26 @@ case class ScalaPresentationCompiler(
   override def semanticTokens(
       params: VirtualFileParams
   ): CompletableFuture[ju.List[Node]] =
-    compilerAccess.withInterruptableCompiler(Some(params))(
+    compilerAccess.withInterruptableCompiler(
       new ju.ArrayList[Node](),
       params.token()
     ) { access =>
       val driver = access.compiler()
       new PcSemanticTokensProvider(driver, params).provide().asJava
-    }
+    }(params.toQueryContext)
 
   override def inlayHints(
       params: InlayHintsParams
   ): ju.concurrent.CompletableFuture[ju.List[l.InlayHint]] =
-    compilerAccess.withInterruptableCompiler(Some(params))(
+    compilerAccess.withInterruptableCompiler(
       new ju.ArrayList[l.InlayHint](),
       params.token(),
     ) { access =>
       val driver = access.compiler()
       new PcInlayHintsProvider(driver, params, search)
         .provide()
         .asJava
-    }
+    }(params.toQueryContext)
 
   override def getTasty(
       targetUri: URI,
@@ -173,7 +174,7 @@ case class ScalaPresentationCompiler(
     }
 
   def complete(params: OffsetParams): CompletableFuture[l.CompletionList] =
-    compilerAccess.withInterruptableCompiler(Some(params))(
+    compilerAccess.withInterruptableCompiler(
       EmptyCompletionList(),
       params.token()
     ) { access =>
@@ -188,61 +189,60 @@ case class ScalaPresentationCompiler(
         folderPath,
         completionItemPriority
       ).completions()
-
-    }
+    }(params.toQueryContext)
 
   def definition(params: OffsetParams): CompletableFuture[DefinitionResult] =
-    compilerAccess.withInterruptableCompiler(Some(params))(
+    compilerAccess.withInterruptableCompiler(
       DefinitionResultImpl.empty,
       params.token()
     ) { access =>
       val driver = access.compiler()
       PcDefinitionProvider(driver, params, search).definitions()
-    }
+    }(params.toQueryContext)
 
   override def typeDefinition(
       params: OffsetParams
   ): CompletableFuture[DefinitionResult] =
-    compilerAccess.withInterruptableCompiler(Some(params))(
+    compilerAccess.withInterruptableCompiler(
       DefinitionResultImpl.empty,
       params.token()
     ) { access =>
       val driver = access.compiler()
       PcDefinitionProvider(driver, params, search).typeDefinitions()
-    }
+    }(params.toQueryContext)
 
   def documentHighlight(
       params: OffsetParams
   ): CompletableFuture[ju.List[DocumentHighlight]] =
-    compilerAccess.withInterruptableCompiler(Some(params))(
+    compilerAccess.withInterruptableCompiler(
       List.empty[DocumentHighlight].asJava,
       params.token()
     ) { access =>
       val driver = access.compiler()
       PcDocumentHighlightProvider(driver, params).highlights.asJava
-    }
+    }(params.toQueryContext)
 
   override def references(
       params: ReferencesRequest
   ): CompletableFuture[ju.List[ReferencesResult]] =
-    compilerAccess.withNonInterruptableCompiler(Some(params.file()))(
+    compilerAccess.withNonInterruptableCompiler(
       List.empty[ReferencesResult].asJava,
       params.file().token,
     ) { access =>
       val driver = access.compiler()
       PcReferencesProvider(driver, params)
         .references()
         .asJava
-    }
+    }(params.file().toQueryContext)
 
   def inferExpectedType(params: OffsetParams): CompletableFuture[ju.Optional[String]] =
-    compilerAccess.withInterruptableCompiler(Some(params))(
+    compilerAccess.withInterruptableCompiler(
       Optional.empty(),
       params.token,
     ) { access =>
       val driver = access.compiler()
       new InferExpectedType(search, driver, params).infer().asJava
-    }
+    }(params.toQueryContext)
 
   def shutdown(): Unit =
     compilerAccess.shutdown()
@@ -257,44 +257,42 @@ case class ScalaPresentationCompiler(
       symbol: String
   ): CompletableFuture[Optional[IPcSymbolInformation]] =
     compilerAccess.withNonInterruptableCompiler[Optional[IPcSymbolInformation]](
-      None
-    )(
       Optional.empty(),
       EmptyCancelToken,
     ) { access =>
       SymbolInformationProvider(using access.compiler().currentCtx)
         .info(symbol)
         .map(_.asJava)
         .asJava
-    }
+    }(emptyQueryContext)
 
   def semanticdbTextDocument(
       filename: URI,
       code: String
   ): CompletableFuture[Array[Byte]] =
     val virtualFile = CompilerVirtualFileParams(filename, code)
-    compilerAccess.withNonInterruptableCompiler(Some(virtualFile))(
+    compilerAccess.withNonInterruptableCompiler(
       Array.empty[Byte],
       EmptyCancelToken
     ) { access =>
       val driver = access.compiler()
       val provider = SemanticdbTextDocumentProvider(driver, folderPath)
       provider.textDocument(filename, code)
-    }
+    }(virtualFile.toQueryContext)
 
   def completionItemResolve(
       item: l.CompletionItem,
       symbol: String
   ): CompletableFuture[l.CompletionItem] =
-    compilerAccess.withNonInterruptableCompiler(None)(
+    compilerAccess.withNonInterruptableCompiler(
       item,
       EmptyCancelToken
     ) { access =>
       val driver = access.compiler()
       CompletionItemResolver.resolve(item, symbol, search, config)(using
         driver.currentCtx
       )
-    }
+    }(emptyQueryContext)
 
   def autoImports(
       name: String,
@@ -303,7 +301,7 @@ case class ScalaPresentationCompiler(
   ): CompletableFuture[
     ju.List[scala.meta.pc.AutoImportsResult]
   ] =
-    compilerAccess.withNonInterruptableCompiler(Some(params))(
+    compilerAccess.withNonInterruptableCompiler(
       List.empty[scala.meta.pc.AutoImportsResult].asJava,
       params.token()
     ) { access =>
@@ -318,13 +316,13 @@ case class ScalaPresentationCompiler(
       )
         .autoImports(isExtension)
         .asJava
-    }
+    }(params.toQueryContext)
 
   def implementAbstractMembers(
       params: OffsetParams
   ): CompletableFuture[ju.List[l.TextEdit]] =
     val empty: ju.List[l.TextEdit] = new ju.ArrayList[l.TextEdit]()
-    compilerAccess.withNonInterruptableCompiler(Some(params))(
+    compilerAccess.withNonInterruptableCompiler(
       empty,
       params.token()
     ) { pc =>
@@ -335,31 +333,31 @@ case class ScalaPresentationCompiler(
         search,
         config
       )
-    }
+    }(params.toQueryContext)
   end implementAbstractMembers
 
   override def insertInferredType(
       params: OffsetParams
   ): CompletableFuture[ju.List[l.TextEdit]] =
     val empty: ju.List[l.TextEdit] = new ju.ArrayList[l.TextEdit]()
-    compilerAccess.withNonInterruptableCompiler(Some(params))(
+    compilerAccess.withNonInterruptableCompiler(
       empty,
       params.token()
     ) { pc =>
       new InferredTypeProvider(params, pc.compiler(), config, search)
         .inferredTypeEdits()
         .asJava
-    }
+    }(params.toQueryContext)
 
   override def inlineValue(
       params: OffsetParams
   ): CompletableFuture[ju.List[l.TextEdit]] =
     val empty: Either[String, List[l.TextEdit]] = Right(List())
     (compilerAccess
-      .withInterruptableCompiler(Some(params))(empty, params.token()) { pc =>
+      .withInterruptableCompiler(empty, params.token()) { pc =>
         new PcInlineValueProviderImpl(pc.compiler(), params)
           .getInlineTextEdits()
-      })
+      }(params.toQueryContext))
       .thenApply {
         case Right(edits: List[TextEdit]) => edits.asJava
         case Left(error: String) => throw new DisplayableException(error)
@@ -371,7 +369,7 @@ case class ScalaPresentationCompiler(
       extractionPos: OffsetParams
   ): CompletableFuture[ju.List[l.TextEdit]] =
     val empty: ju.List[l.TextEdit] = new ju.ArrayList[l.TextEdit]()
-    compilerAccess.withInterruptableCompiler(Some(range))(empty, range.token()) {
+    compilerAccess.withInterruptableCompiler(empty, range.token()) {
       pc =>
         new ExtractMethodProvider(
           range,
@@ -382,7 +380,7 @@ case class ScalaPresentationCompiler(
         )
           .extractMethod()
           .asJava
-    }
+    }(range.toQueryContext)
   end extractMethod
 
   override def convertToNamedArguments(
@@ -397,13 +395,13 @@ case class ScalaPresentationCompiler(
   ): CompletableFuture[ju.List[l.TextEdit]] =
     val empty: Either[String, List[l.TextEdit]] = Right(List())
     (compilerAccess
-      .withNonInterruptableCompiler(Some(params))(empty, params.token()) { pc =>
+      .withNonInterruptableCompiler(empty, params.token()) { pc =>
         new ConvertToNamedArgumentsProvider(
           pc.compiler(),
           params,
           argIndices
         ).convertToNamedArguments
-      })
+      }(params.toQueryContext))
       .thenApplyAsync {
         case Left(error: String) => throw new DisplayableException(error)
         case Right(edits: List[l.TextEdit]) => edits.asJava
@@ -413,53 +411,53 @@ case class ScalaPresentationCompiler(
       params: ju.List[OffsetParams]
   ): CompletableFuture[ju.List[l.SelectionRange]] =
     CompletableFuture.completedFuture {
-      compilerAccess.withSharedCompiler(params.asScala.headOption)(
+      compilerAccess.withSharedCompiler(
         List.empty[l.SelectionRange].asJava
       ) { pc =>
         new SelectionRangeProvider(
           pc.compiler(),
           params,
         ).selectionRange().asJava
-      }
+      }(params.asScala.headOption.map(_.toQueryContext).getOrElse(emptyQueryContext))
     }
   end selectionRange
 
   def hover(
       params: OffsetParams
   ): CompletableFuture[ju.Optional[HoverSignature]] =
-    compilerAccess.withNonInterruptableCompiler(Some(params))(
+    compilerAccess.withNonInterruptableCompiler(
       ju.Optional.empty[HoverSignature](),
       params.token()
     ) { access =>
       val driver = access.compiler()
       HoverProvider.hover(params, driver, search, config.hoverContentType())
-    }
+    }(params.toQueryContext)
   end hover
 
   def prepareRename(
       params: OffsetParams
   ): CompletableFuture[ju.Optional[l.Range]] =
-    compilerAccess.withNonInterruptableCompiler(Some(params))(
+    compilerAccess.withNonInterruptableCompiler(
       Optional.empty[l.Range](),
       params.token()
     ) { access =>
       val driver = access.compiler()
       Optional.ofNullable(
         PcRenameProvider(driver, params, None).prepareRename().orNull
       )
-    }
+    }(params.toQueryContext)
 
   def rename(
       params: OffsetParams,
       name: String
   ): CompletableFuture[ju.List[l.TextEdit]] =
-    compilerAccess.withNonInterruptableCompiler(Some(params))(
+    compilerAccess.withNonInterruptableCompiler(
       List[l.TextEdit]().asJava,
       params.token()
     ) { access =>
       val driver = access.compiler()
       PcRenameProvider(driver, params, Some(name)).rename().asJava
-    }
+    }(params.toQueryContext)
 
   def newInstance(
       buildTargetIdentifier: String,
@@ -473,24 +471,24 @@ case class ScalaPresentationCompiler(
     )
 
   def signatureHelp(params: OffsetParams): CompletableFuture[l.SignatureHelp] =
-    compilerAccess.withNonInterruptableCompiler(Some(params))(
+    compilerAccess.withNonInterruptableCompiler(
       new l.SignatureHelp(),
       params.token()
     ) { access =>
       val driver = access.compiler()
       SignatureHelpProvider.signatureHelp(driver, params, search)
-    }
+    }(params.toQueryContext)
 
   override def didChange(
       params: VirtualFileParams
   ): CompletableFuture[ju.List[l.Diagnostic]] =
     CompletableFuture.completedFuture(Nil.asJava)
 
   override def didClose(uri: URI): Unit =
-    compilerAccess.withNonInterruptableCompiler(None)(
+    compilerAccess.withNonInterruptableCompiler(
       (),
       EmptyCancelToken
-    ) { access => access.compiler().close(uri) }
+    ) { access => access.compiler().close(uri) }(emptyQueryContext)
 
   override def withExecutorService(
       executorService: ExecutorService
@@ -515,4 +513,19 @@ case class ScalaPresentationCompiler(
 
   override def isLoaded() = compilerAccess.isLoaded()
 
+  def additionalReportData() =
+    s"""|Scala version: $scalaVersion
+        |Classpath:
+        |${classpath
+          .map(path => s"$path [${if path.exists then "exists" else "missing"} ]")
+          .mkString(", ")}
+        |Options:
+        |${options.mkString(" ")}
+        |""".stripMargin
+
+  extension (params: VirtualFileParams)
+    def toQueryContext = PcQueryContext(Some(params), additionalReportData)
+
+  def emptyQueryContext = PcQueryContext(None, additionalReportData)
+
 end ScalaPresentationCompiler

project/Build.scala

@@ -1485,7 +1485,7 @@ object Build {
       BuildInfoPlugin.buildInfoDefaultSettings
 
   lazy val presentationCompilerSettings = {
-    val mtagsVersion = "1.4.2"
+    val mtagsVersion = "1.5.1"
     Seq(
       libraryDependencies ++= Seq(
         "org.lz4" % "lz4-java" % "1.8.0",