@@ -12,6 +12,9 @@ import NameNormalizer._
12
12
import SyntheticsSupport ._
13
13
import dotty .tools .dotc .core .NameKinds
14
14
15
+ // Please use this only for things defined in the api.scala file
16
+ import dotty .tools .{scaladoc => api }
17
+
15
18
trait ClassLikeSupport :
16
19
self : TastyParser =>
17
20
import qctx .reflect ._
@@ -45,7 +48,7 @@ trait ClassLikeSupport:
45
48
.filter(s => s.exists && ! s.isHiddenByVisibility)
46
49
.map( _.tree.asInstanceOf [DefDef ])
47
50
constr.fold(Nil )(
48
- _.termParamss.map(pList => TermParameterList (pList.params.map(p => mkParameter(p, parameterModifier)), paramListModifier(pList.params)))
51
+ _.termParamss.map(pList => api. TermParameterList (pList.params.map(p => mkParameter(p, parameterModifier)), paramListModifier(pList.params)))
49
52
)
50
53
51
54
if classDef.symbol.flags.is(Flags .Module ) then Kind .Object
@@ -141,11 +144,12 @@ trait ClassLikeSupport:
141
144
dd.symbol.extendedSymbol.map { extSym =>
142
145
val memberInfo = unwrapMemberInfo(c, dd.symbol)
143
146
val typeParams = dd.symbol.extendedTypeParams.map(mkTypeArgument(_, memberInfo.genericTypes))
144
- val termParams = dd.symbol.extendedTermParamLists.zipWithIndex.flatMap { case (paramList, index) =>
145
- memberInfo.paramLists(index) match
146
- case EvidenceOnlyParameterList => Nil
147
- case info : RegularParameterList =>
148
- Seq (TermParameterList (paramList.params.map(mkParameter(_, memberInfo = info)), paramListModifier(paramList.params)))
147
+ val termParams = dd.symbol.extendedTermParamLists.zipWithIndex.flatMap { case (termParamList, index) =>
148
+ memberInfo.termParamLists(index) match
149
+ case MemberInfo .EvidenceOnlyParameterList => None
150
+ case MemberInfo .RegularParameterList (info) =>
151
+ Some (api.TermParameterList (termParamList.params.map(mkParameter(_, memberInfo = info)), paramListModifier(termParamList.params)))
152
+ case _ => assert(false , " memberInfo.termParamLists contains a type parameter list !" )
149
153
}
150
154
val target = ExtensionTarget (
151
155
extSym.symbol.normalizedName,
@@ -347,11 +351,12 @@ trait ClassLikeSupport:
347
351
Right (genericTypes.map(mkTypeArgument(_, memberInfo.genericTypes, memberInfo.contextBounds))) +:
348
352
paramLists.zipWithIndex.flatMap { (pList, index) =>
349
353
memberInfo.paramLists(index) match
350
- case EvidenceOnlyParameterList => None
351
- case info : RegularParameterList =>
354
+ case MemberInfo . EvidenceOnlyParameterList => None
355
+ case MemberInfo . RegularParameterList (info) =>
352
356
Some (Left (TermParameterList (pList.params.map(
353
357
mkParameter(_, paramPrefix, memberInfo = info)), paramListModifier(pList.params)
354
358
)))
359
+ case _ => assert(false , " memberInfo.termParamLists contains a type parameter list !" )
355
360
}
356
361
)
357
362
@@ -393,7 +398,7 @@ trait ClassLikeSupport:
393
398
val inlinePrefix = if argument.symbol.flags.is(Flags .Inline ) then " inline " else " "
394
399
val nameIfNotSynthetic = Option .when(! argument.symbol.flags.is(Flags .Synthetic ))(argument.symbol.normalizedName)
395
400
val name = argument.symbol.normalizedName
396
- TermParameter (
401
+ api. TermParameter (
397
402
argument.symbol.getAnnotations(),
398
403
inlinePrefix + prefix(argument.symbol),
399
404
nameIfNotSynthetic,
@@ -493,16 +498,26 @@ trait ClassLikeSupport:
493
498
deprecated = deprecated
494
499
)
495
500
496
- object EvidenceOnlyParameterList
497
- type RegularParameterList = Map [String , TypeRepr ]
498
- type ParameterList = RegularParameterList | EvidenceOnlyParameterList .type
499
501
500
502
case class MemberInfo (
501
- genericTypes : Map [String , TypeBounds ],
502
- paramLists : List [ParameterList ],
503
+ paramLists : List [MemberInfo .ParameterList ],
503
504
res : TypeRepr ,
504
505
contextBounds : Map [String , DSignature ] = Map .empty,
505
- )
506
+ ){
507
+ val genericTypes : Map [String , TypeBounds ] = paramLists.collect{ case MemberInfo .TypeParameterList (types) => types }.headOption.getOrElse(Map ())
508
+
509
+ val termParamLists : List [MemberInfo .ParameterList ] = paramLists.filter(_.isTerm)
510
+ }
511
+
512
+ object MemberInfo :
513
+ enum ParameterList (val isTerm : Boolean , val isUsing : Boolean ):
514
+ inline def isType = ! isTerm
515
+ case EvidenceOnlyParameterList extends ParameterList (isTerm = true , isUsing = false )
516
+ case RegularParameterList (m : Map [String , TypeRepr ])(isUsing : Boolean ) extends ParameterList (isTerm = true , isUsing)
517
+ case TypeParameterList (m : Map [String , TypeBounds ]) extends ParameterList (isTerm = false , isUsing = false )
518
+
519
+ export ParameterList .{RegularParameterList , EvidenceOnlyParameterList , TypeParameterList }
520
+
506
521
507
522
508
523
def unwrapMemberInfo (c : ClassDef , symbol : Symbol ): MemberInfo =
@@ -520,10 +535,12 @@ trait ClassLikeSupport:
520
535
symbol.paramSymss.flatten.find(_.name == name).exists(_.flags.is(Flags .Implicit ))
521
536
522
537
def handlePolyType (memberInfo : MemberInfo , polyType : PolyType ): MemberInfo =
523
- MemberInfo (polyType.paramNames.zip(polyType.paramBounds).toMap, memberInfo.paramLists, polyType.resType)
538
+ val typeParamList = MemberInfo .TypeParameterList (polyType.paramNames.zip(polyType.paramBounds).toMap)
539
+ MemberInfo (memberInfo.paramLists :+ typeParamList, polyType.resType)
524
540
525
541
def handleMethodType (memberInfo : MemberInfo , methodType : MethodType ): MemberInfo =
526
542
val rawParams = methodType.paramNames.zip(methodType.paramTypes).toMap
543
+ val isUsing = methodType.isImplicit
527
544
val (evidences, notEvidences) = rawParams.partition(e => isSyntheticEvidence(e._1))
528
545
529
546
def findParamRefs (t : TypeRepr ): Seq [ParamRef ] = t match
@@ -552,22 +569,23 @@ trait ClassLikeSupport:
552
569
553
570
val newParams = notEvidences ++ paramsThatLookLikeContextBounds
554
571
555
- val newLists : List [ParameterList ] = if newParams.isEmpty && contextBounds.nonEmpty
556
- then memberInfo.paramLists ++ Seq (EvidenceOnlyParameterList )
557
- else memberInfo.paramLists ++ Seq (newParams)
572
+ val termParamList = if newParams.isEmpty && contextBounds.nonEmpty
573
+ then MemberInfo .EvidenceOnlyParameterList
574
+ else MemberInfo .RegularParameterList (newParams)(isUsing)
575
+
558
576
559
- MemberInfo (memberInfo.genericTypes, newLists , methodType.resType, contextBounds.toMap)
577
+ MemberInfo (memberInfo.paramLists :+ termParamList , methodType.resType, contextBounds.toMap)
560
578
561
579
def handleByNameType (memberInfo : MemberInfo , byNameType : ByNameType ): MemberInfo =
562
- MemberInfo (memberInfo.genericTypes, memberInfo. paramLists, byNameType.underlying)
580
+ MemberInfo (memberInfo.paramLists, byNameType.underlying)
563
581
564
582
def recursivelyCalculateMemberInfo (memberInfo : MemberInfo ): MemberInfo = memberInfo.res match
565
583
case p : PolyType => recursivelyCalculateMemberInfo(handlePolyType(memberInfo, p))
566
584
case m : MethodType => recursivelyCalculateMemberInfo(handleMethodType(memberInfo, m))
567
585
case b : ByNameType => handleByNameType(memberInfo, b)
568
586
case _ => memberInfo
569
587
570
- recursivelyCalculateMemberInfo(MemberInfo (Map .empty, List .empty, baseTypeRepr))
588
+ recursivelyCalculateMemberInfo(MemberInfo (List .empty, baseTypeRepr))
571
589
572
590
private def paramListModifier (parameters : Seq [ValDef ]): String =
573
591
if parameters.size > 0 then
0 commit comments