Hardlink fake symbols

Author: tanishiking

compiler/src/dotty/tools/dotc/semanticdb/TypeOps.scala

@@ -415,12 +415,13 @@ object SymbolScopeOps:
   import Scala3.{_, given}
   extension (syms: List[SemanticSymbol])
     def sscope(using linkMode: LinkMode)(using SemanticSymbolBuilder, TypeOps, Context): s.Scope =
-      linkMode match {
-        case LinkMode.SymlinkChildren =>
-          s.Scope(symlinks = syms.map(_.symbolName))
-        case LinkMode.HardlinkChildren =>
-          s.Scope(hardlinks = syms.map(_.symbolInfo(Set.empty)))
-      }
+      // if syms contains FakeSymbol, hardlink those symbols
+      // because fake symbols don't appear in Symbols section.
+      // If we symlink those fake symbols, we always fail to lookup those symlinked symbols.
+      if syms.exists(s => s.isInstanceOf[FakeSymbol]) || linkMode == LinkMode.HardlinkChildren then
+        s.Scope(hardlinks = syms.map(_.symbolInfo(Set.empty)(using LinkMode.HardlinkChildren)))
+      else
+        s.Scope(symlinks = syms.map(_.symbolName))
 
     def sscopeOpt(using linkMode: LinkMode)(using SemanticSymbolBuilder, TypeOps, Context): Option[s.Scope] =
       if syms.nonEmpty then Some(syms.sscope) else None

tests/semanticdb/metac.expect

@@ -57,9 +57,9 @@ advanced/C# => class C [typeparam T ] extends Object { self: C[T] => +3 decls }
 advanced/C#[T] => typeparam T 
 advanced/C#`<init>`(). => primary ctor <init> [typeparam T ](): C[T]
 advanced/C#t(). => method t => T
-advanced/HKClass# => class HKClass [typeparam F [unknown T: <?>] <: <?>] extends Object { self: HKClass[F] => +3 decls }
-advanced/HKClass#[F] => typeparam F [unknown T: <?>] <: <?>
-advanced/HKClass#`<init>`(). => primary ctor <init> [typeparam F [unknown T: <?>] <: <?>](): HKClass[F]
+advanced/HKClass# => class HKClass [typeparam F [typeparam T ] <: <?>] extends Object { self: HKClass[F] => +3 decls }
+advanced/HKClass#[F] => typeparam F [typeparam T ] <: <?>
+advanced/HKClass#`<init>`(). => primary ctor <init> [typeparam F [typeparam T ] <: <?>](): HKClass[F]
 advanced/HKClass#foo(). => method foo [typeparam T , typeparam U ](param x: F[T, U]): String
 advanced/HKClass#foo().(x) => param x: F[T, U]
 advanced/HKClass#foo().[T] => typeparam T 
@@ -323,8 +323,8 @@ example/Anonymous#foo. => val method foo Foo
 example/Anonymous#locally(). => method locally [typeparam A ](param x: A): A
 example/Anonymous#locally().(x) => param x: A
 example/Anonymous#locally().[A] => typeparam A 
-example/Anonymous#m1(). => method m1 [typeparam T [unknown _: <?>]]: Nothing
-example/Anonymous#m1().[T] => typeparam T [unknown _: <?>]
+example/Anonymous#m1(). => method m1 [typeparam T [type _ ]]: Nothing
+example/Anonymous#m1().[T] => typeparam T [type _ ]
 example/Anonymous#m2(). => method m2 => Map[_, List[_] forSome { type _  }] forSome { type _  }
 local0 => val local x: Function1[Int, Int]
 local1 => final class $anon extends Object with Foo { self: $anon => +1 decls }
@@ -1325,9 +1325,9 @@ ext/Extension$package.readInto(). => method readInto [typeparam T ](param s: Str
 ext/Extension$package.readInto().(s) => param s: String
 ext/Extension$package.readInto().(x$2) => implicit param x$2: Read[T]
 ext/Extension$package.readInto().[T] => typeparam T 
-ext/Functor# => trait Functor [typeparam F [unknown _: <?>]] extends Object { self: Functor[F] => +3 decls }
-ext/Functor#[F] => typeparam F [unknown _: <?>]
-ext/Functor#`<init>`(). => primary ctor <init> [typeparam F [unknown _: <?>]](): Functor[F]
+ext/Functor# => trait Functor [typeparam F [type _ ]] extends Object { self: Functor[F] => +3 decls }
+ext/Functor#[F] => typeparam F [type _ ]
+ext/Functor#`<init>`(). => primary ctor <init> [typeparam F [type _ ]](): Functor[F]
 ext/Functor#map(). => abstract method map [typeparam T , typeparam U ](param t: F[T])(param f: Function1[T, U]): F[U]
 ext/Functor#map().(f) => param f: Function1[T, U]
 ext/Functor#map().(t) => param t: F[T]
@@ -3862,12 +3862,12 @@ _empty_/Copy# => trait Copy [typeparam In  <: Txn[In], typeparam Out  <: Txn[Out
 _empty_/Copy#[In] => typeparam In  <: Txn[In]
 _empty_/Copy#[Out] => typeparam Out  <: Txn[Out]
 _empty_/Copy#`<init>`(). => primary ctor <init> [typeparam In  <: Txn[In], typeparam Out  <: Txn[Out]](): Copy[In, Out]
-_empty_/Copy#apply(). => method apply [typeparam Repr [unknown ~: <?>] <: Elem[~]](param in: Repr[In]): Repr[Out]
+_empty_/Copy#apply(). => method apply [typeparam Repr [typeparam ~  <: Txn[~]] <: Elem[~]](param in: Repr[In]): Repr[Out]
 _empty_/Copy#apply().(in) => param in: Repr[In]
-_empty_/Copy#apply().[Repr] => typeparam Repr [unknown ~: <?>] <: Elem[~]
-_empty_/Copy#copyImpl(). => abstract method copyImpl [typeparam Repr [unknown ~: <?>] <: Elem[~]](param in: Repr[In]): Repr[Out]
+_empty_/Copy#apply().[Repr] => typeparam Repr [typeparam ~  <: Txn[~]] <: Elem[~]
+_empty_/Copy#copyImpl(). => abstract method copyImpl [typeparam Repr [typeparam ~  <: Txn[~]] <: Elem[~]](param in: Repr[In]): Repr[Out]
 _empty_/Copy#copyImpl().(in) => param in: Repr[In]
-_empty_/Copy#copyImpl().[Repr] => typeparam Repr [unknown ~: <?>] <: Elem[~]
+_empty_/Copy#copyImpl().[Repr] => typeparam Repr [typeparam ~  <: Txn[~]] <: Elem[~]
 _empty_/Elem# => trait Elem [typeparam T  <: Txn[T]] extends Object { self: Elem[T] => +2 decls }
 _empty_/Elem#[T] => typeparam T  <: Txn[T]
 _empty_/Elem#`<init>`(). => primary ctor <init> [typeparam T  <: Txn[T]](): Elem[T]
@@ -4026,10 +4026,10 @@ _empty_/Concrete# => class Concrete extends NullaryTest[Int, List] { self: Concr
 _empty_/Concrete#`<init>`(). => primary ctor <init> (): Concrete
 _empty_/Concrete#nullary2(). => method nullary2 => Int
 _empty_/Concrete#nullary3(). => method nullary3 => List[Int]
-_empty_/NullaryTest# => abstract class NullaryTest [typeparam T , typeparam m [unknown s: <?>]] extends Object { self: NullaryTest[T, m] => +9 decls }
+_empty_/NullaryTest# => abstract class NullaryTest [typeparam T , typeparam m [typeparam s ]] extends Object { self: NullaryTest[T, m] => +9 decls }
 _empty_/NullaryTest#[T] => typeparam T 
-_empty_/NullaryTest#[m] => typeparam m [unknown s: <?>]
-_empty_/NullaryTest#`<init>`(). => primary ctor <init> [typeparam T , typeparam m [unknown s: <?>]](): NullaryTest[T, m]
+_empty_/NullaryTest#[m] => typeparam m [typeparam s ]
+_empty_/NullaryTest#`<init>`(). => primary ctor <init> [typeparam T , typeparam m [typeparam s ]](): NullaryTest[T, m]
 _empty_/NullaryTest#nullary(). => method nullary => String
 _empty_/NullaryTest#nullary2(). => abstract method nullary2 => T
 _empty_/NullaryTest#nullary3(). => abstract method nullary3 => m[T]
@@ -4460,8 +4460,8 @@ types/Test.C#TypeType.T5# => type T5 [typeparam U ] = U
 types/Test.C#TypeType.T5#[U] => typeparam U 
 types/Test.C#TypeType.m2(). => method m2 [typeparam T2  = C]: Nothing
 types/Test.C#TypeType.m2().[T2] => typeparam T2  = C
-types/Test.C#TypeType.m3(). => method m3 [typeparam M3 [unknown _: <?>]]: Nothing
-types/Test.C#TypeType.m3().[M3] => typeparam M3 [unknown _: <?>]
+types/Test.C#TypeType.m3(). => method m3 [typeparam M3 [type _ ]]: Nothing
+types/Test.C#TypeType.m3().[M3] => typeparam M3 [type _ ]
 types/Test.C#`<init>`(). => primary ctor <init> (): C
 types/Test.C#annType1. => val method annType1 T @ann[T]
 types/Test.C#annType2. => val method annType2 T @ann1 @ann2
@@ -4482,8 +4482,8 @@ types/Test.C#superType2. => val method superType2 Int
 types/Test.C#superType3. => val method superType3 Int
 types/Test.C#thisType1. => val method thisType1 C.this.type
 types/Test.C#thisType2. => val method thisType2 C.this.type
-types/Test.C#typeLambda1(). => method typeLambda1 [typeparam M [unknown _: <?>]]: Nothing
-types/Test.C#typeLambda1().[M] => typeparam M [unknown _: <?>]
+types/Test.C#typeLambda1(). => method typeLambda1 [typeparam M [type _ ]]: Nothing
+types/Test.C#typeLambda1().[M] => typeparam M [type _ ]
 types/Test.C#typeRef1. => val method typeRef1 C
 types/Test.C#typeRef2. => val method typeRef2 p.C
 types/Test.C#typeRef3. => val method typeRef3 T#C