[sbt] Add support for using the Scala 3 language in sbt 2 build files #SCL-24201 fixed

vasilmkd · builduser · commit 127d0ddf2eab · 2025-08-28T17:44:33.000+02:00
(cherry picked from commit f22c50f)
diff --git a/sbt/sbt-api/src/org/jetbrains/sbt/language/SbtLanguageScala3.scala b/sbt/sbt-api/src/org/jetbrains/sbt/language/SbtLanguageScala3.scala
@@ -2,10 +2,9 @@ package org.jetbrains.sbt.language
 
 import com.intellij.lang.{DependentLanguage, Language}
 import com.intellij.openapi.fileTypes.LanguageFileType
-import org.jetbrains.plugins.scala.ScalaLanguage
 
 final class SbtLanguageScala3 private
-  extends Language(ScalaLanguage.INSTANCE, "sbt (scala 3)")
+  extends Language(SbtLanguage.INSTANCE, "sbt Scala 3")
     with DependentLanguage {
 
   override def getAssociatedFileType: LanguageFileType = SbtFileType
diff --git a/sbt/sbt-api/src/org/jetbrains/sbt/language/SbtLanguageSubstitutor.scala b/sbt/sbt-api/src/org/jetbrains/sbt/language/SbtLanguageSubstitutor.scala
diff --git a/sbt/sbt-impl/resources/META-INF/sbt.xml b/sbt/sbt-impl/resources/META-INF/sbt.xml
@@ -31,6 +31,8 @@
 
     <extensions defaultExtensionNs="com.intellij">
         <lang.parserDefinition language="sbt" implementationClass="org.jetbrains.sbt.language.SbtParserDefinition"/>
+        <lang.parserDefinition language="sbt Scala 3" implementationClass="org.jetbrains.sbt.language.SbtParserDefinitionScala3"/>
+        <lang.substitutor language="sbt" implementationClass="org.jetbrains.sbt.language.SbtLanguageSubstitutor"/>
         <lang.fileViewProviderFactory language="sbt"
                                       implementationClass="org.jetbrains.sbt.language.SbtFileViewProviderFactory"/>
         <fileType name="sbt" language="sbt" extensions="sbt"
diff --git a/sbt/sbt-impl/src/org/jetbrains/sbt/language/SbtBuildModuleSupport.scala b/sbt/sbt-impl/src/org/jetbrains/sbt/language/SbtBuildModuleSupport.scala
@@ -0,0 +1,33 @@
+package org.jetbrains.sbt.language
+
+import com.intellij.openapi.application.ApplicationManager
+import com.intellij.openapi.module.{Module, ModuleManager}
+import com.intellij.openapi.project.Project
+import org.jetbrains.plugins.scala.project.ModuleExt
+import org.jetbrains.sbt.Sbt
+import org.jetbrains.sbt.project.SbtBuildModuleUriProvider
+import org.jetbrains.sbt.project.module.SbtModule.Build
+
+object SbtBuildModuleSupport {
+  def findBuildModule(module: Module, project: Project): Option[Module] =
+    if (module.hasBuildModuleType)
+      Some(module)
+    else {
+      val manager = ModuleManager.getInstance(project)
+      val modules = manager.getModules
+      val sbtBuildModuleUri = SbtBuildModuleUriProvider.getBuildModuleUri(module)
+      val result = for {
+        buildModuleUri <- sbtBuildModuleUri
+        module <- modules.find(Build(_) == buildModuleUri)
+      } yield module
+
+      if (result.isEmpty && ApplicationManager.getApplication.isUnitTestMode) {
+        //NOTE: right now this legacy way of determining build module is left for tests only
+        //It simplifies setup logic for tests which work with sbt files.
+        //In theory we could remove this extra branch, but we would need to improve setup for tests
+        val buildModuleName = module.getName + Sbt.BuildModuleSuffix
+        modules.find(_.getName == buildModuleName)
+      }
+      else result
+    }
+}
diff --git a/sbt/sbt-impl/src/org/jetbrains/sbt/language/SbtFileImpl.scala b/sbt/sbt-impl/src/org/jetbrains/sbt/language/SbtFileImpl.scala
@@ -1,8 +1,7 @@
 package org.jetbrains.sbt
 package language
 
-import com.intellij.openapi.application.ApplicationManager
-import com.intellij.openapi.module.{Module, ModuleManager, ModuleUtilCore}
+import com.intellij.openapi.module.{Module, ModuleUtilCore}
 import com.intellij.openapi.roots.ProjectRootManager
 import com.intellij.psi._
 import com.intellij.psi.search.{GlobalSearchScope, searches}
@@ -12,9 +11,7 @@ import org.jetbrains.plugins.scala.extensions.PsiClassExt
 import org.jetbrains.plugins.scala.lang.psi.ScDeclarationSequenceHolder
 import org.jetbrains.plugins.scala.lang.psi.api.toplevel.typedef.ScTypeDefinition
 import org.jetbrains.plugins.scala.lang.psi.impl._
-import org.jetbrains.plugins.scala.project.{ModuleExt, ScalaFeatures}
-import org.jetbrains.sbt.project.SbtBuildModuleUriProvider
-import org.jetbrains.sbt.project.module.SbtModule.{Build, Imports}
+import org.jetbrains.sbt.project.module.SbtModule.Imports
 
 import scala.jdk.CollectionConverters._
 
@@ -88,26 +85,7 @@ final class SbtFileImpl private[language](provider: FileViewProvider)
   }
 
   override def findBuildModule(module: Module): Option[Module] =
-    if (module.hasBuildModuleType)
-      Some(module)
-    else {
-      val manager = ModuleManager.getInstance(getProject)
-      val modules = manager.getModules
-      val sbtBuildModuleUri = SbtBuildModuleUriProvider.getBuildModuleUri(module)
-      val result = for {
-        buildModuleUri <- sbtBuildModuleUri
-        module <- modules.find(Build(_) == buildModuleUri)
-      } yield module
-
-      if (result.isEmpty && ApplicationManager.getApplication.isUnitTestMode) {
-        //NOTE: right now this legacy way of determining build module is left for tests only
-        //It simplifies setup logic for tests which work with sbt files.
-        //In theory we could remove this extra branch, but we would need to improve setup for tests
-        val buildModuleName = module.getName + Sbt.BuildModuleSuffix
-        modules.find(_.getName == buildModuleName)
-      }
-      else result
-    }
+    SbtBuildModuleSupport.findBuildModule(module, getProject)
 }
 
 object SbtFileImpl {
diff --git a/sbt/sbt-impl/src/org/jetbrains/sbt/language/SbtFileViewProvider.scala b/sbt/sbt-impl/src/org/jetbrains/sbt/language/SbtFileViewProvider.scala
@@ -0,0 +1,12 @@
+package org.jetbrains.sbt.language
+
+import com.intellij.lang.Language
+import com.intellij.openapi.vfs.VirtualFile
+import com.intellij.psi.{PsiManager, SingleRootFileViewProvider}
+
+private final class SbtFileViewProvider(
+  manager: PsiManager,
+  file: VirtualFile,
+  eventSystemEnabled: Boolean,
+  language: Language
+) extends SingleRootFileViewProvider(manager, file, eventSystemEnabled, language)
diff --git a/sbt/sbt-impl/src/org/jetbrains/sbt/language/SbtFileViewProviderFactory.scala b/sbt/sbt-impl/src/org/jetbrains/sbt/language/SbtFileViewProviderFactory.scala
@@ -11,5 +11,5 @@ final class SbtFileViewProviderFactory extends FileViewProviderFactory {
                                       language: Language,
                                       manager: PsiManager,
                                       eventSystemEnabled: Boolean): SingleRootFileViewProvider =
-    new SingleRootFileViewProvider(manager, file, eventSystemEnabled, language) {}
+    new SbtFileViewProvider(manager, file, eventSystemEnabled, language)
 }
diff --git a/sbt/sbt-impl/src/org/jetbrains/sbt/language/SbtLanguageSubstitutor.scala b/sbt/sbt-impl/src/org/jetbrains/sbt/language/SbtLanguageSubstitutor.scala
@@ -0,0 +1,23 @@
+package org.jetbrains.sbt.language
+
+import com.intellij.lang.Language
+import com.intellij.openapi.module.ModuleUtilCore
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.vfs.VirtualFile
+import com.intellij.psi.LanguageSubstitutor
+import com.intellij.util.SlowOperations
+import org.jetbrains.plugins.scala.project.ModuleExt
+
+import scala.util.Using
+
+final class SbtLanguageSubstitutor extends LanguageSubstitutor {
+  override def getLanguage(file: VirtualFile, project: Project): Language = {
+    val module = Using.resource(SlowOperations.knownIssue("SCL-21147")) { _ =>
+      ModuleUtilCore.findModuleForFile(file, project)
+    }
+    Option(module).flatMap(SbtBuildModuleSupport.findBuildModule(_, project)) match {
+      case Some(buildModule) if buildModule.hasScala3 => SbtLanguageScala3.INSTANCE
+      case _ => null
+    }
+  }
+}
diff --git a/sbt/sbt-impl/src/org/jetbrains/sbt/language/SbtParserDefinitionScala3.scala b/sbt/sbt-impl/src/org/jetbrains/sbt/language/SbtParserDefinitionScala3.scala
@@ -0,0 +1,20 @@
+package org.jetbrains.sbt.language
+
+import com.intellij.lang.PsiParser
+import com.intellij.lexer.Lexer
+import com.intellij.openapi.project.Project
+import com.intellij.psi.FileViewProvider
+import com.intellij.psi.tree.IFileElementType
+import org.jetbrains.plugins.scala.lang.lexer.ScalaLexer
+import org.jetbrains.plugins.scala.lang.parser.{ScalaParser, ScalaParserDefinitionBase}
+import org.jetbrains.plugins.scala.lang.psi.api.ScalaFile
+
+final class SbtParserDefinitionScala3 extends ScalaParserDefinitionBase {
+  override def createFile(viewProvider: FileViewProvider): ScalaFile = new SbtFileImpl(viewProvider)
+
+  override def createLexer(project: Project): Lexer = new ScalaLexer(/* isScala3 = */ true, project)
+
+  override def createParser(project: Project): PsiParser = new ScalaParser(isScala3 = true)
+
+  override val getFileNodeType: IFileElementType = new IFileElementType("sbt.FILE", SbtLanguageScala3.INSTANCE)
+}
diff --git a/sbt/sbt-project-importing-tests/test/org/jetbrains/sbt/project/SbtBuildFilesLanguageTest.scala b/sbt/sbt-project-importing-tests/test/org/jetbrains/sbt/project/SbtBuildFilesLanguageTest.scala
@@ -0,0 +1,51 @@
+package org.jetbrains.sbt.project
+
+import com.intellij.openapi.vfs.VfsUtil
+import com.intellij.pom.java.LanguageLevel
+import com.intellij.psi.{PsiFile, PsiManager}
+import org.jetbrains.plugins.scala.Scala3Language
+import org.jetbrains.plugins.scala.extensions.PathExt
+import org.jetbrains.plugins.scala.util.TestUtils
+import org.jetbrains.sbt.SbtVersion
+import org.jetbrains.sbt.language.SbtLanguageScala3
+import org.junit.Assert.{assertNotNull, assertTrue}
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+
+import java.nio.file.Path
+
+@RunWith(classOf[JUnit4])
+class SbtBuildFilesLanguageTest extends SbtExternalSystemImportingTestLike {
+  override protected def getTestDataProjectPath: String =
+    s"${TestUtils.getTestDataPath}/sbt/projects/${getTestName(true)}"
+
+  override protected def copyTestProjectToTemporaryDir: Boolean = true
+
+  override protected def projectJdkLanguageLevel: LanguageLevel = LanguageLevel.JDK_17
+
+  @Test
+  def buildFilesLanguage(): Unit = {
+    injectVariable(
+      getTestProjectPath / "project" / "build.properties",
+      "$LATEST_SBT_2$",
+      SbtVersion.Latest.Sbt_2.minor
+    )
+
+    importProject(false)
+
+    val dayEnumPsiFile = findPsiFile(getTestProjectPath / "project" / "Day.scala")
+    val buildSbtPsiFile = findPsiFile(getTestProjectPath / "build.sbt")
+
+    assertTrue(s"Day.scala enum is not a Scala 3 source file", dayEnumPsiFile.getLanguage.isKindOf(Scala3Language.INSTANCE))
+    assertTrue(s"build.sbt is not a Scala 3 sbt build file", buildSbtPsiFile.getLanguage.isKindOf(SbtLanguageScala3.INSTANCE))
+  }
+
+  private def findPsiFile(path: Path): PsiFile = {
+    val virtualFile = VfsUtil.findFile(path, true)
+    assertNotNull(s"Could not find a virtual file for: $path", virtualFile)
+    val psiFile = PsiManager.getInstance(getProject).findFile(virtualFile)
+    assertNotNull(s"Could not find a PSI file for: $path", psiFile)
+    psiFile
+  }
+}
diff --git a/sbt/sbt-project-importing-tests/test/org/jetbrains/sbt/project/SbtProjectStructureImportingLike.scala b/sbt/sbt-project-importing-tests/test/org/jetbrains/sbt/project/SbtProjectStructureImportingLike.scala
@@ -16,13 +16,12 @@ import org.jetbrains.jps.model.module.JpsModuleSourceRootType
 import org.jetbrains.plugins.scala.util.TestUtils
 import org.jetbrains.plugins.scala.util.assertions.CollectionsAssertions.assertCollectionEquals
 import org.jetbrains.sbt.actions.SbtDirectoryCompletionContributor
-import org.jetbrains.sbt.project.utils.{ProjectComparisonOptions, ProjectStructureComparisonContext}
-import org.jetbrains.sbt.project.utils.CompilerUtils
+import org.jetbrains.sbt.project.utils.{CompilerUtils, ProjectComparisonOptions, ProjectStructureComparisonContext}
 import org.jetbrains.sbt.settings.SbtSettings
 import org.junit.Assert
 import org.junit.Assert.fail
 
-import java.nio.file.{Files, Path}
+import java.nio.file.Path
 import scala.jdk.CollectionConverters.{CollectionHasAsScala, SeqHasAsJava}
 
 abstract class SbtProjectStructureImportingLike extends SbtExternalSystemImportingTestLike
@@ -249,12 +248,6 @@ abstract class SbtProjectStructureImportingLike extends SbtExternalSystemImporti
     ProjectStructureDsl.testResources := Nil
   }
 
-  protected def injectVariable(file: Path, variableName: String, value: String): Unit = {
-    val fileContent = Files.readString(file)
-    val updatedContent = fileContent.replace(variableName, value)
-    Files.writeString(file, updatedContent)
-  }
-
   protected def buildCrossProjectAndAssertNoWarningsOrErrors(): Unit = {
     CompilerUtils.buildCrossProjectAndAssertNoWarningsOrErrors(getProject)
   }
diff --git a/scala/scala-impl/test/org/jetbrains/sbt/project/SbtExternalSystemImportingTestLike.scala b/scala/scala-impl/test/org/jetbrains/sbt/project/SbtExternalSystemImportingTestLike.scala
@@ -7,6 +7,8 @@ import org.jetbrains.sbt.Sbt
 import org.jetbrains.sbt.project.settings.SbtProjectSettings
 import org.jetbrains.sbt.settings.SbtSettings
 
+import java.nio.file.{Files, Path}
+
 trait SbtExternalSystemImportingTestLike extends ScalaExternalSystemImportingTestBase {
 
   override protected def getExternalSystemConfigFileName: String = Sbt.BuildFile
@@ -48,4 +50,10 @@ trait SbtExternalSystemImportingTestLike extends ScalaExternalSystemImportingTes
     settings.setSeparateProdAndTestSources(prodTestSourcesSeparated)
     SbtSettings.getInstance(project).linkProject(settings)
   }
+
+  protected def injectVariable(file: Path, variableName: String, value: String): Unit = {
+    val fileContent = Files.readString(file)
+    val updatedContent = fileContent.replace(variableName, value)
+    Files.writeString(file, updatedContent)
+  }
 }
diff --git a/scala/scala-impl/testdata/sbt/projects/buildFilesLanguage/build.sbt b/scala/scala-impl/testdata/sbt/projects/buildFilesLanguage/build.sbt
@@ -0,0 +1,7 @@
+inline def projectName: String =
+  "buildFilesLanguage"
+end projectName
+
+name := { s"$projectName-${Day.Tuesday}" }
+
+scalaVersion := "3.7.2"
diff --git a/scala/scala-impl/testdata/sbt/projects/buildFilesLanguage/project/Day.scala b/scala/scala-impl/testdata/sbt/projects/buildFilesLanguage/project/Day.scala
@@ -0,0 +1,2 @@
+enum Day:
+  case Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday
diff --git a/scala/scala-impl/testdata/sbt/projects/buildFilesLanguage/project/build.properties b/scala/scala-impl/testdata/sbt/projects/buildFilesLanguage/project/build.properties
@@ -0,0 +1 @@
+sbt.version=$LATEST_SBT_2$

Original file line number	Diff line number	Diff line change
`@@ -11,5 +11,5 @@ final class SbtFileViewProviderFactory extends FileViewProviderFactory {`
`11`	`11`	`language: Language,`
`12`	`12`	`manager: PsiManager,`
`13`	`13`	`eventSystemEnabled: Boolean): SingleRootFileViewProvider =`
`14`		`- new SingleRootFileViewProvider(manager, file, eventSystemEnabled, language) {}`
	`14`	`+ new SbtFileViewProvider(manager, file, eventSystemEnabled, language)`
`15`	`15`	`}`