Add enum type param support in sourceSymbol

Author: rochala

Diff for: compiler/src/dotty/tools/dotc/core/Symbols.scala

@@ -32,6 +32,8 @@ import dotty.tools.dotc.classpath.FileUtils.isScalaBinary
 
 import scala.compiletime.uninitialized
 import dotty.tools.tasty.TastyVersion
+import dotty.tools.dotc.transform.CheckUnused.isSynthetic
+import dotty.tools.dotc.config.PathResolver.ppcp
 
 object Symbols extends SymUtils {
 
@@ -357,13 +359,25 @@ object Symbols extends SymUtils {
         targets.match
           case (tp: NamedType) :: _ => tp.symbol.sourceSymbol
           case _                    => this
-      else if (denot.is(Synthetic)) {
+      else if denot.is(Synthetic) then
         val linked = denot.linkedClass
         if (linked.exists && !linked.is(Synthetic))
           linked
         else
           denot.owner.sourceSymbol
-      }
+      else if (
+        denot.is(TypeParam) &&
+        denot.maybeOwner.maybeOwner.isAllOf(EnumCase) &&
+        denot.maybeOwner.isPrimaryConstructor
+      ) then
+        val enclosingEnumCase = denot.maybeOwner.maybeOwner
+        val caseTypeParam = enclosingEnumCase.typeParams.find(_.name == denot.name)
+        if caseTypeParam.exists(_.is(Synthetic)) then
+          val enumClass = enclosingEnumCase.info.firstParent.typeSymbol
+          val sourceTypeParam = enumClass.typeParams.find(_.name == denot.name)
+          sourceTypeParam.getOrElse(this)
+        else
+          caseTypeParam.getOrElse(this)
       else if (denot.isPrimaryConstructor)
         denot.owner.sourceSymbol
       else this

Diff for: compiler/src/dotty/tools/dotc/interactive/Interactive.scala

@@ -144,6 +144,7 @@ object Interactive {
 
     (  sym == tree.symbol
     || sym.exists && sym == tree.symbol.sourceSymbol
+    || sym.exists && sym.sourceSymbol == tree.symbol
     || !include.isEmpty && sym.name == tree.symbol.name && sym.maybeOwner != tree.symbol.maybeOwner
        && (  include.isOverridden && overrides(sym, tree.symbol)
           || include.isOverriding && overrides(tree.symbol, sym)

Diff for: language-server/test/dotty/tools/languageserver/DefinitionTest.scala

@@ -378,4 +378,38 @@ class DefinitionTest {
     .definition(m3 to m4, Nil)
     .definition(m5 to m6, Nil)
     .definition(m7 to m8, Nil)
+
+  @Test def typeParam: Unit = {
+    code"""|class Foo[${m1}T${m2}]:
+           |  def test: ${m3}T${m4}"""
+      .definition(m3 to m4, List(m1 to m2))
+  }
+
+  @Test def enumTypeParam: Unit = {
+    code"""|enum Test[${m1}T${m2}]:
+           |  case EnumCase(value: ${m3}T${m4})"""
+      .definition(m3 to m4, List(m1 to m2))
+  }
+
+  @Test def extMethodTypeParam: Unit = {
+    code"""extension [${m1}T${m2}](string: String) def xxxx(y: ${m3}T${m4}) = ???"""
+      .definition(m3 to m4, List(m1 to m2))
+  }
+
+  @Test def typeParamCovariant: Unit = {
+    code"""|class Foo[+${m1}T${m2}]:
+           |  def test: ${m3}T${m4}"""
+      .definition(m3 to m4, List(m1 to m2))
+  }
+
+  @Test def enumTypeParamCovariant: Unit = {
+    code"""|enum Test[+${m1}T${m2}]:
+           |  case EnumCase(value: ${m3}T${m4})"""
+      .definition(m3 to m4, List(m1 to m2))
+  }
+
+  @Test def extMethodTypeParamCovariant: Unit = {
+    code"""extension [+${m1}T${m2}](string: String) def xxxx(y: ${m3}T${m4}) = ???"""
+      .definition(m3 to m4, List(m1 to m2))
+  }
 }

Diff for: presentation-compiler/test/dotty/tools/pc/tests/definition/PcDefinitionSuite.scala

@@ -478,6 +478,33 @@ class PcDefinitionSuite extends BasePcDefinitionSuite:
          |""".stripMargin
     )
 
+  @Test def `enum-class-type-param` =
+    check(
+      """|
+         |enum Options[<<AA>>]:
+         |  case Some(x: A@@A)
+         |  case None extends Options[Nothing]
+         |""".stripMargin
+    )
+
+  @Test def `enum-class-type-param-covariant` =
+    check(
+      """|
+         |enum Options[+<<AA>>]:
+         |  case Some(x: A@@A)
+         |  case None extends Options[Nothing]
+         |""".stripMargin
+    )
+
+  @Test def `enum-class-type-param-duplicate` =
+    check(
+      """|
+         |enum Testing[AA]:
+         |  case Some[<<AA>>](x: A@@A) extends Testing[AA]
+         |  case None extends Testing[Nothing]
+         |""".stripMargin
+    )
+
   @Test def `derives-def` =
     check(
       """|

Diff for: project/Build.scala

@@ -520,7 +520,7 @@ object Build {
     "scala2-library-tasty"
   )
 
-  val enableBspAllProjects = false
+  val enableBspAllProjects = true
 
   // Settings used when compiling dotty with a non-bootstrapped dotty
   lazy val commonBootstrappedSettings = commonDottySettings ++ Seq(

Diff for: tasty/test/dotty/tools/tasty/BuildTastyVersionTest.scala

@@ -7,12 +7,12 @@ import TastyBuffer._
 
 // Tests ensuring TASTY version emitted by compiler is matching expected TASTY version
 class BuildTastyVersionTest {
-  
+
   val CurrentTastyVersion = TastyVersion(TastyFormat.MajorVersion, TastyFormat.MinorVersion, TastyFormat.ExperimentalVersion)
-  
+
   // Needs to be defined in build Test/envVars
   val ExpectedTastyVersionEnvVar = "EXPECTED_TASTY_VERSION"
-  
+
   @Test def testBuildTastyVersion(): Unit = {
     val expectedVersion = sys.env.get(ExpectedTastyVersionEnvVar)
       .getOrElse(fail(s"Env variable $ExpectedTastyVersionEnvVar not defined"))