Resolve symbols in refinements by fake symbols

Author: tanishiking

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

@@ -20,26 +20,26 @@ import dotty.tools.dotc.core.Names.Designator
 class TypeOps:
   import SymbolScopeOps._
   import Scala3.given
-  private val paramRefSymtab = mutable.Map[(LambdaType, Name), Symbol]()
-  private val refinementSymtab = mutable.Map[(RefinedType, Name), Symbol]()
+  private val paramRefSymtab = mutable.Map[(LambdaType, Name), SemanticSymbol]()
+  private val refinementSymtab = mutable.Map[(RefinedType, Name), SemanticSymbol]()
 
   // save generated fake symbols so we can insert them into symbols section of SemanticDB
   val fakeSymbols = mutable.Set[FakeSymbol]()
   given typeOps: TypeOps = this
 
-  extension [T <: LambdaType | RefinedType](symtab: mutable.Map[(T, Name), Symbol])
+  extension [T <: LambdaType | RefinedType](symtab: mutable.Map[(T, Name), SemanticSymbol])
     private def lookup(
       binder: T,
       name: Name,
-    )(using Context): Option[Symbol] =
+    )(using Context): Option[SemanticSymbol] =
       symtab.get((binder, name))
 
-  extension [T <: LambdaType | RefinedType](symtab: mutable.Map[(T, Name), Symbol])
+  extension [T <: LambdaType | RefinedType](symtab: mutable.Map[(T, Name), SemanticSymbol])
     private def lookupOrErr(
       binder: T,
       name: Name,
       parent: Symbol,
-    )(using Context): Option[Symbol] =
+    )(using Context): Option[SemanticSymbol] =
       // In case refinement or type param cannot be accessed from traverser and
       // no symbols are registered to the symbol table, fall back to Type.member
       symtab.lookup(binder, name) match
@@ -241,11 +241,22 @@ class TypeOps:
         // when TypeRef refers the refinement of RefinedType e.g.
         // TypeRef for `foo.B` in `trait T[A] { val foo: { type B = A } = ???; def bar(b: foo.B) = () }` has NoSymbol
         case TypeRef(pre, name: Name) =>
+          def lookupSym(tpe: Type): Option[SemanticSymbol] = {
+            tpe match {
+              case rt: RefinedType =>
+                refinementSymtab.lookupOrErr(rt, name, rt.typeSymbol)
+              case rec: RecType =>
+                lookupSym(rec.parent)
+              case AndType(tp1, tp2) =>
+                lookupSym(tp1).orElse(lookupSym(tp2))
+              case OrType(tp1, tp2) =>
+                lookupSym(tp1).orElse(lookupSym(tp2))
+              case _ =>
+                None
+            }
+          }
           val spre = if tpe.hasTrivialPrefix then s.Type.Empty else loop(pre)
-          val maybeSym = pre.widen.dealias match
-            case rt: RefinedType =>
-              refinementSymtab.lookupOrErr(rt, name, rt.typeSymbol)
-            case _ => None
+          val maybeSym = lookupSym(pre.widen.dealias)
           maybeSym match
             case Some(sym) =>
               s.TypeRef(spre, sym.symbolName, Seq.empty)
@@ -368,7 +379,9 @@ class TypeOps:
 
           val decls: List[SemanticSymbol] = refinedInfos.map { (name, info) =>
             refinementSymtab.lookup(rt, name).getOrElse {
-              RefinementSymbol(sym, name, info).tap(registerFakeSymbol)
+              val fakeSym = RefinementSymbol(sym, name, info).tap(registerFakeSymbol)
+              refinementSymtab((rt, name)) = fakeSym
+              fakeSym
             }
           }
           val sdecls = decls.sscopeOpt(using LinkMode.HardlinkChildren)

tests/semanticdb/expect/Advanced.expect.scala

@@ -42,6 +42,10 @@ object Test/*<-advanced::Test.*/ {
         ()
     }
   }
+
+  // see: https://github.com/lampepfl/dotty/pull/14608#discussion_r835642563
+  lazy val foo/*<-advanced::Test.foo.*/: (reflect.Selectable/*->scala::reflect::Selectable#*/ { type A/*<-local16*/ = Int/*->scala::Int#*/ }) &/*->scala::`&`#*/ (reflect.Selectable/*->scala::reflect::Selectable#*/ { type A/*<-local17*/ = Int/*->scala::Int#*/; val a/*<-local18*/: A/*->local17*/ }) = ???/*->scala::Predef.`???`().*/
+  def bar/*<-advanced::Test.bar().*/: foo/*->advanced::Test.foo.*/.A = foo/*->advanced::Test.foo.*/.a
 }
 
 

tests/semanticdb/expect/Advanced.scala

@@ -42,6 +42,10 @@ object Test {
         ()
     }
   }
+
+  // see: https://github.com/lampepfl/dotty/pull/14608#discussion_r835642563
+  lazy val foo: (reflect.Selectable { type A = Int }) & (reflect.Selectable { type A = Int; val a: A }) = ???
+  def bar: foo.A = foo.a
 }
 
 

tests/semanticdb/metac.expect

@@ -48,9 +48,9 @@ Schema => SemanticDB v4
 Uri => Advanced.scala
 Text => empty
 Language => Scala
-Symbols => 55 entries
-Occurrences => 114 entries
-Synthetics => 3 entries
+Symbols => 62 entries
+Occurrences => 130 entries
+Synthetics => 4 entries
 
 Symbols:
 advanced/C# => class C [typeparam T ] extends Object { self: C[T] => +3 decls }
@@ -80,10 +80,12 @@ advanced/Structural#s2(). => method s2 => Object { abstract val method x Int }
 advanced/Structural#s3(). => method s3 => Object { abstract method m (param x: Int): Int }
 advanced/Structural#s4(). => method s4 (param a: Int): Object { abstract val method x Int }
 advanced/Structural#s4().(a) => param a: Int
-advanced/Test. => final object Test extends Object { self: Test.type => +11 decls }
+advanced/Test. => final object Test extends Object { self: Test.type => +13 decls }
+advanced/Test.bar(). => method bar => foo.A
 advanced/Test.e. => val method e Wildcards
 advanced/Test.e1. => val method e1 List[_] forSome { type _  }
 advanced/Test.e1x. => val method e1x Any
+advanced/Test.foo. => lazy val method foo Selectable { abstract type A  = Int } & Selectable { abstract field a: local20; abstract type A  = Int }
 advanced/Test.s. => val method s Structural
 advanced/Test.s1. => val method s1 Object { abstract val method x Int }
 advanced/Test.s1x. => val method s1x Int
@@ -108,6 +110,11 @@ local11 => abstract val method x Int
 local12 => type B  = A
 local13 => val local e3: List[local14]
 local15 => val local e3x: local14
+local16 => type A  = Int
+local17 => type A  = Int
+local18 => abstract val method a A
+local19 => abstract type A  = Int
+local21 => abstract field a: A
 
 Occurrences:
 [0:8..0:16): advanced <- advanced/
@@ -208,27 +215,44 @@ Occurrences:
 [40:12..40:15): e3x <- local15
 [40:18..40:20): e3 -> local13
 [40:21..40:25): head -> scala/collection/IterableOps#head().
-[48:6..48:13): HKClass <- advanced/HKClass#
-[48:14..48:15): F <- advanced/HKClass#[F]
-[48:20..48:21): T <- advanced/HKClass#`<init>`().[F][T]
-[48:28..48:29): U <- advanced/HKClass#`<init>`().[F][U]
-[48:36..48:37): U -> advanced/HKClass#`<init>`().[F][U]
-[48:39..48:40): T -> advanced/HKClass#`<init>`().[F][T]
-[49:6..49:9): foo <- advanced/HKClass#foo().
-[49:10..49:11): T <- advanced/HKClass#foo().[T]
-[49:12..49:13): U <- advanced/HKClass#foo().[U]
-[49:15..49:16): x <- advanced/HKClass#foo().(x)
-[49:18..49:19): F -> advanced/HKClass#[F]
-[49:20..49:21): T -> advanced/HKClass#foo().[T]
-[49:23..49:24): U -> advanced/HKClass#foo().[U]
-[49:28..49:34): String -> scala/Predef.String#
-[49:37..49:38): x -> advanced/HKClass#foo().(x)
-[49:39..49:47): toString -> scala/Tuple2#toString().
+[46:11..46:14): foo <- advanced/Test.foo.
+[46:17..46:24): reflect -> scala/reflect/
+[46:25..46:35): Selectable -> scala/reflect/Selectable#
+[46:43..46:44): A <- local16
+[46:47..46:50): Int -> scala/Int#
+[46:54..46:55): & -> scala/`&`#
+[46:57..46:64): reflect -> scala/reflect/
+[46:65..46:75): Selectable -> scala/reflect/Selectable#
+[46:83..46:84): A <- local17
+[46:87..46:90): Int -> scala/Int#
+[46:96..46:97): a <- local18
+[46:99..46:100): A -> local17
+[46:106..46:109): ??? -> scala/Predef.`???`().
+[47:6..47:9): bar <- advanced/Test.bar().
+[47:11..47:14): foo -> advanced/Test.foo.
+[47:19..47:22): foo -> advanced/Test.foo.
+[52:6..52:13): HKClass <- advanced/HKClass#
+[52:14..52:15): F <- advanced/HKClass#[F]
+[52:20..52:21): T <- advanced/HKClass#`<init>`().[F][T]
+[52:28..52:29): U <- advanced/HKClass#`<init>`().[F][U]
+[52:36..52:37): U -> advanced/HKClass#`<init>`().[F][U]
+[52:39..52:40): T -> advanced/HKClass#`<init>`().[F][T]
+[53:6..53:9): foo <- advanced/HKClass#foo().
+[53:10..53:11): T <- advanced/HKClass#foo().[T]
+[53:12..53:13): U <- advanced/HKClass#foo().[U]
+[53:15..53:16): x <- advanced/HKClass#foo().(x)
+[53:18..53:19): F -> advanced/HKClass#[F]
+[53:20..53:21): T -> advanced/HKClass#foo().[T]
+[53:23..53:24): U -> advanced/HKClass#foo().[U]
+[53:28..53:34): String -> scala/Predef.String#
+[53:37..53:38): x -> advanced/HKClass#foo().(x)
+[53:39..53:47): toString -> scala/Tuple2#toString().
 
 Synthetics:
 [27:12..27:16):s.s1 => reflectiveSelectable(*)
 [29:12..29:16):s.s2 => reflectiveSelectable(*)
 [31:12..31:16):s.s3 => reflectiveSelectable(*)
+[47:19..47:24):foo.a => *[foo.A]
 
 expect/Annotations.scala
 ------------------------