diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/BasicSupport.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/BasicSupport.scala index 43d28a80606f..77cf553c82c9 100644 --- a/scaladoc/src/dotty/tools/scaladoc/tasty/BasicSupport.scala +++ b/scaladoc/src/dotty/tools/scaladoc/tasty/BasicSupport.scala @@ -5,13 +5,18 @@ import collection.JavaConverters._ import dotty.tools.scaladoc._ import scala.quoted._ +import SymOps._ +import ScaladocSupport._ + trait BasicSupport: self: TastyParser => - import qctx.reflect._ - object SymOps extends SymOps[qctx.type](qctx) - export SymOps._ - def parseAnnotation(annotTerm: Term): Annotation = + object SymOpsWithLinkCache extends SymOpsWithLinkCache + export SymOpsWithLinkCache._ + + + def parseAnnotation(using Quotes)(annotTerm: reflect.Term): Annotation = + import reflect._ import dotty.tools.dotc.ast.Trees.{SeqLiteral} val dri = annotTerm.tpe.typeSymbol.dri def inner(t: Term): List[Annotation.AnnotationParameter] = t match { @@ -24,7 +29,6 @@ trait BasicSupport: case other => List(Annotation.UnresolvedParameter(None, other.show)) } - val params = annotTerm match case Apply(target, appliedWith) => { appliedWith.flatMap(inner) @@ -32,10 +36,10 @@ trait BasicSupport: Annotation(dri, params) - extension (sym: Symbol) + extension (using Quotes)(sym: reflect.Symbol) def documentation = sym.docstring.map(parseComment(_, sym.tree)) - def source(using Quotes) = + def source = val path = sym.pos.map(_.sourceFile.jpath).filter(_ != null).map(_.toAbsolutePath) path.map(TastyMemberSource(_, sym.pos.get.startLine)) @@ -49,5 +53,4 @@ trait BasicSupport: }.map(parseAnnotation) def isLeftAssoc: Boolean = !sym.name.endsWith(":") - - + end extension diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala index bcb87f2d5428..c3a539af766e 100644 --- a/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala +++ b/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala @@ -4,16 +4,25 @@ import collection.JavaConverters._ import dotty.tools.scaladoc._ import dotty.tools.scaladoc.{Signature => DSignature} +import scala.quoted._ + +import SymOps._ +import NameNormalizer._ +import SyntheticsSupport._ + trait ClassLikeSupport: self: TastyParser => import qctx.reflect._ - private def bareClasslikeKind(symbol: Symbol): Kind = - if symbol.flags.is(Flags.Module) then Kind.Object - else if symbol.flags.is(Flags.Trait) then Kind.Trait(Nil, Nil) - else if symbol.flags.is(Flags.Enum) then Kind.Enum(Nil, Nil) - else if symbol.flags.is(Flags.Enum) && symbol.flags.is(Flags.Case) then Kind.EnumCase(Kind.Object) - else Kind.Class(Nil, Nil) + private given qctx.type = qctx + + private def bareClasslikeKind(using Quotes)(symbol: reflect.Symbol): Kind = + import reflect._ + if symbol.flags.is(Flags.Module) then Kind.Object + else if symbol.flags.is(Flags.Trait) then Kind.Trait(Nil, Nil) + else if symbol.flags.is(Flags.Enum) then Kind.Enum(Nil, Nil) + else if symbol.flags.is(Flags.Enum) && symbol.flags.is(Flags.Case) then Kind.EnumCase(Kind.Object) + else Kind.Class(Nil, Nil) private def kindForClasslike(classDef: ClassDef): Kind = def typeArgs = classDef.getTypeParams.map(mkTypeArgument(_)) @@ -208,7 +217,8 @@ trait ClassLikeSupport: } ).map(_.copy(inheritedFrom = inheritance)) - extension (c: ClassDef) + extension (using Quotes)(c: reflect.ClassDef) + def membersToDocument = c.body.filterNot(_.symbol.isHiddenByVisibility) def getNonTrivialInheritedMemberTrees = @@ -216,6 +226,7 @@ trait ClassLikeSupport: .filter(s => s.maybeOwner != defn.ObjectClass && s.maybeOwner != defn.AnyClass) .map(_.tree) + extension (c: ClassDef) def extractMembers: Seq[Member] = { val inherited = c.getNonTrivialInheritedMemberTrees.collect { case dd: DefDef if !dd.symbol.isClassConstructor && !(dd.symbol.isSuperBridgeMethod || dd.symbol.isDefaultHelperMethod) => dd @@ -265,7 +276,7 @@ trait ClassLikeSupport: if parentSymbol != defn.ObjectClass && parentSymbol != defn.AnyClass yield (parentTree, parentSymbol) - def getConstructors: List[Symbol] = membersToDocument.collect { + def getConstructors: List[Symbol] = c.membersToDocument.collect { case d: DefDef if d.symbol.isClassConstructor && c.constructor.symbol != d.symbol => d.symbol }.toList @@ -444,7 +455,7 @@ trait ClassLikeSupport: modifiers = modifiers, annotations = symbol.getAnnotations(), signature = signature, - sources = symbol.source(using qctx), + sources = symbol.source, origin = origin, inheritedFrom = inheritedFrom, graph = graph, diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/JavadocAnchorCreator.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/JavadocAnchorCreator.scala index 5f9751d0d8e3..ea7dc32a7e58 100644 --- a/scaladoc/src/dotty/tools/scaladoc/tasty/JavadocAnchorCreator.scala +++ b/scaladoc/src/dotty/tools/scaladoc/tasty/JavadocAnchorCreator.scala @@ -5,33 +5,32 @@ import scala.quoted._ import dotty.tools.scaladoc.util.Escape._ import scala.util.matching.Regex -trait JavadocAnchorCreator: - self: SymOps[_] => +object JavadocAnchorCreator: - import self.q.reflect._ + private def javadocPrimitives(using Quotes)(sym: reflect.Symbol) = + import reflect.* + if sym == defn.IntClass then Some("int") + else if sym == defn.FloatClass then Some("float") + else if sym == defn.DoubleClass then Some("double") + else if sym == defn.LongClass then Some("long") + else if sym == defn.ByteClass then Some("byte") + else if sym == defn.BooleanClass then Some("boolean") + else if sym == defn.CharClass then Some("char") + else if sym == defn.ShortClass then Some("short") + else if sym == defn.ObjectClass then Some("java.lang.Object") + else None - private val javadocPrimitivesMap = Map( - defn.IntClass -> "int", - defn.FloatClass -> "float", - defn.DoubleClass -> "double", - defn.LongClass -> "long", - defn.ByteClass -> "byte", - defn.BooleanClass -> "boolean", - defn.CharClass -> "char", - defn.ShortClass -> "short", - defn.ObjectClass -> "java.lang.Object" - ) - - private def transformPrimitiveType(tpe: TypeRepr): String = tpe.classSymbol - .flatMap(javadocPrimitivesMap.get) + private def transformPrimitiveType(using Quotes)(tpe: reflect.TypeRepr): String = tpe.classSymbol + .flatMap(javadocPrimitives) .filter(_ => !tpe.typeSymbol.isTypeParam) .getOrElse(tpe.show) - private def transformType(tpe: TypeRepr): String = tpe.simplified match { - case AppliedType(tpe, typeList) if tpe.classSymbol.fold(false)(_ == defn.ArrayClass) => transformType(typeList.head) + ":A" - case AppliedType(tpe, typeList) if tpe.classSymbol.fold(false)(_ == defn.RepeatedParamClass) => transformType(typeList.head) + "..." - case AppliedType(tpe, typeList) => transformPrimitiveType(tpe) - case other => transformPrimitiveType(other) - } + private def transformType(using Quotes)(tpe: reflect.TypeRepr): String = + import reflect.* + tpe.simplified match + case AppliedType(tpe, typeList) if tpe.classSymbol.fold(false)(_ == defn.ArrayClass) => transformType(typeList.head) + ":A" + case AppliedType(tpe, typeList) if tpe.classSymbol.fold(false)(_ == defn.RepeatedParamClass) => transformType(typeList.head) + "..." + case AppliedType(tpe, typeList) => transformPrimitiveType(tpe) + case other => transformPrimitiveType(other) - def getJavadocType(s: TypeRepr) = transformType(s) + def getJavadocType(using Quotes)(s: reflect.TypeRepr) = transformType(s) diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/NameNormalizer.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/NameNormalizer.scala index 24366288557c..932d437353ab 100644 --- a/scaladoc/src/dotty/tools/scaladoc/tasty/NameNormalizer.scala +++ b/scaladoc/src/dotty/tools/scaladoc/tasty/NameNormalizer.scala @@ -4,9 +4,13 @@ import dotty.tools.scaladoc._ import dotty.tools.dotc.core.StdNames.nme.keywords import dotty.tools.dotc.core.Names.termName -trait NameNormalizer { self: TastyParser => - import qctx.reflect._ - extension (s: Symbol) def normalizedName: String = { +import scala.quoted._ +import SymOps._ + +object NameNormalizer { + + extension (using Quotes)(s: reflect.Symbol) def normalizedName: String = { + import reflect.* val withoutGivenPrefix = if s.isGiven then s.name.stripPrefix("given_") else s.name val withoutObjectSuffix = if s.flags.is(Flags.Module) then withoutGivenPrefix.stripSuffix("$") else withoutGivenPrefix val constructorNormalizedName = if s.isClassConstructor then "this" else withoutObjectSuffix diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/PackageSupport.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/PackageSupport.scala index 04d4a66ff6cc..77ce9854620d 100644 --- a/scaladoc/src/dotty/tools/scaladoc/tasty/PackageSupport.scala +++ b/scaladoc/src/dotty/tools/scaladoc/tasty/PackageSupport.scala @@ -3,10 +3,14 @@ package tasty import collection.JavaConverters._ +import SymOps._ + trait PackageSupport: self: TastyParser => import qctx.reflect._ + private given qctx.type = qctx + def parsePackage(pck: PackageClause): (String, Member) = val name = pck.symbol.fullName (name, Member(name, pck.symbol.dri, Kind.Package)) diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/ScalaDocSupport.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/ScalaDocSupport.scala index 2a41c3251727..1c634df8c918 100644 --- a/scaladoc/src/dotty/tools/scaladoc/tasty/ScalaDocSupport.scala +++ b/scaladoc/src/dotty/tools/scaladoc/tasty/ScalaDocSupport.scala @@ -6,10 +6,12 @@ import scala.jdk.CollectionConverters._ import dotty.tools.scaladoc.Scaladoc.CommentSyntax import dotty.tools.scaladoc.tasty.comments.Comment -trait ScaladocSupport { self: TastyParser => - import qctx.reflect._ +import scala.quoted._ - def parseCommentString(comment: String, sym: Symbol, pos: Option[Position]): Comment = +object ScaladocSupport: + + def parseCommentString(using Quotes, DocContext)(comment: String, sym: reflect.Symbol, pos: Option[reflect.Position]): Comment = + import reflect.report val preparsed = comments.Preparser.preparse(comments.Cleaner.clean(comment)) val commentSyntax = @@ -22,22 +24,22 @@ trait ScaladocSupport { self: TastyParser => CommentSyntax.default } - case None => ctx.args.defaultSyntax + case None => summon[DocContext].args.defaultSyntax } val parser = commentSyntax match { case CommentSyntax.Wiki => - comments.WikiCommentParser(comments.Repr(qctx)(sym)) + comments.WikiCommentParser(comments.Repr(quotes)(sym)) case CommentSyntax.Markdown => - comments.MarkdownCommentParser(comments.Repr(qctx)(sym)) + comments.MarkdownCommentParser(comments.Repr(quotes)(sym)) } parser.parse(preparsed) - def parseComment(docstring: String, tree: Tree): Comment = + def parseComment(using Quotes, DocContext)(docstring: String, tree: reflect.Tree): Comment = val commentString: String = if tree.symbol.isClassDef || tree.symbol.owner.isClassDef then import dotty.tools.dotc - given ctx: dotc.core.Contexts.Context = qctx.asInstanceOf[scala.quoted.runtime.impl.QuotesImpl].ctx + given ctx: dotc.core.Contexts.Context = quotes.asInstanceOf[scala.quoted.runtime.impl.QuotesImpl].ctx val sym = tree.symbol.asInstanceOf[dotc.core.Symbols.Symbol] @@ -47,5 +49,3 @@ trait ScaladocSupport { self: TastyParser => docstring parseCommentString(commentString, tree.symbol, Some(tree.pos)) - -} diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/Scaladoc2AnchorCreator.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/Scaladoc2AnchorCreator.scala index 438fd9ed0153..ba59f77495b1 100644 --- a/scaladoc/src/dotty/tools/scaladoc/tasty/Scaladoc2AnchorCreator.scala +++ b/scaladoc/src/dotty/tools/scaladoc/tasty/Scaladoc2AnchorCreator.scala @@ -5,17 +5,12 @@ import scala.quoted._ import dotty.tools.scaladoc.util.Escape._ import scala.util.matching.Regex -trait Scaladoc2AnchorCreator: - self: SymOps[_] => +object Scaladoc2AnchorCreator: - import self.q.reflect._ - - implicit private val printer: Printer[Tree] = Printer.TreeShortCode - - def getScaladoc2Type(t: Tree) = { - (t match { - case d: DefDef => d.show.split("def", 2)(1) - case t: TypeDef => t.show.split("type", 2)(1) - case v: ValDef => v.show.split("val|var", 2)(1) - }).replace(" ","") -} \ No newline at end of file + def getScaladoc2Type(using Quotes)(t: reflect.Tree) = + import reflect.* + val regex = t match + case d: DefDef => "def" + case t: TypeDef => "type" + case v: ValDef => "val|var" + t.show(using Printer.TreeShortCode).split(regex, 2)(1).replace(" ","") diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/SymOps.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/SymOps.scala index 14b6c120b5b3..cdb1e889b29c 100644 --- a/scaladoc/src/dotty/tools/scaladoc/tasty/SymOps.scala +++ b/scaladoc/src/dotty/tools/scaladoc/tasty/SymOps.scala @@ -5,24 +5,22 @@ import scala.quoted._ import dotty.tools.scaladoc.util.Escape._ import scala.collection.mutable.{ Map => MMap } import dotty.tools.io.AbstractFile +import Scaladoc2AnchorCreator.getScaladoc2Type +import JavadocAnchorCreator.getJavadocType -class SymOps[Q <: Quotes](val q: Q) extends JavadocAnchorCreator with Scaladoc2AnchorCreator: - import q.reflect._ +object SymOps: - given Q = q + extension (using Quotes)(sym: reflect.Symbol) - private val externalLinkCache: scala.collection.mutable.Map[AbstractFile, Option[ExternalDocLink]] = MMap() - - extension (sym: Symbol) - def packageName: String = ( + def packageName: String = if (sym.isPackageDef) sym.fullName else sym.maybeOwner.packageName - ) def packageNameSplitted: Seq[String] = sym.packageName.split('.').toList def className: Option[String] = + import reflect._ if (sym.isClassDef && !sym.flags.is(Flags.Package)) Some( Some(sym.maybeOwner).filter(s => s.exists).flatMap(_.className).fold("")(cn => cn + "$") + sym.name ).filterNot(_.contains("package$")) @@ -42,7 +40,9 @@ class SymOps[Q <: Quotes](val q: Q) extends JavadocAnchorCreator with Scaladoc2A else None //TODO: Retrieve string that will match scaladoc anchors + def getVisibility(): Visibility = + import reflect._ import VisibilityScope._ def explicitScope(ownerType: TypeRepr): VisibilityScope = @@ -69,7 +69,9 @@ class SymOps[Q <: Quotes](val q: Q) extends JavadocAnchorCreator with Scaladoc2A // Order here determines order in documenation - def getExtraModifiers(): Seq[Modifier] = Seq( + def getExtraModifiers(): Seq[Modifier] = + import reflect._ + Seq( Flags.Final -> Modifier.Final, Flags.Sealed -> Modifier.Sealed, Flags.Erased -> Modifier.Erased, @@ -81,46 +83,73 @@ class SymOps[Q <: Quotes](val q: Q) extends JavadocAnchorCreator with Scaladoc2A Flags.Open -> Modifier.Open, Flags.Override -> Modifier.Override, Flags.Case -> Modifier.Case, - ).collect { case (flag, mod) if sym.flags.is(flag) => mod } + ).collect { case (flag, mod) if sym.flags.is(flag) => mod } def isHiddenByVisibility(using dctx: DocContext): Boolean = import VisibilityScope._ - !summon[DocContext].args.includePrivateAPI && getVisibility().match + !summon[DocContext].args.includePrivateAPI && sym.getVisibility().match case Visibility.Private(_) => true case Visibility.Protected(ThisScope | ImplicitModuleScope | _: ExplicitModuleScope) => true case _ => false - def shouldDocumentClasslike(using dctx: DocContext): Boolean = !isHiddenByVisibility - && !sym.flags.is(Flags.Synthetic) - && (!sym.flags.is(Flags.Case) || !sym.flags.is(Flags.Enum)) - && !(sym.companionModule.flags.is(Flags.Given)) - + def shouldDocumentClasslike(using dctx: DocContext): Boolean = + import reflect._ + !sym.isHiddenByVisibility + && !sym.flags.is(Flags.Synthetic) + && (!sym.flags.is(Flags.Case) || !sym.flags.is(Flags.Enum)) + && !(sym.companionModule.flags.is(Flags.Given)) - def getCompanionSymbol: Option[Symbol] = Some(sym.companionClass).filter(_.exists) + def getCompanionSymbol: Option[reflect.Symbol] = Some(sym.companionClass).filter(_.exists) - def isCompanionObject: Boolean = sym.flags.is(Flags.Module) && sym.companionClass.exists + def isCompanionObject: Boolean = + import reflect._ + sym.flags.is(Flags.Module) && sym.companionClass.exists - def isGiven: Boolean = sym.flags.is(Flags.Given) + def isGiven: Boolean = + import reflect._ + sym.flags.is(Flags.Given) - def isExported: Boolean = sym.flags.is(Flags.Exported) + def isExported: Boolean = + import reflect._ + sym.flags.is(Flags.Exported) - def isOverridden: Boolean = sym.flags.is(Flags.Override) + def isOverridden: Boolean = + import reflect._ + sym.flags.is(Flags.Override) - def isExtensionMethod: Boolean = sym.flags.is(Flags.ExtensionMethod) + def isExtensionMethod: Boolean = + import reflect._ + sym.flags.is(Flags.ExtensionMethod) - def isArtifact: Boolean = sym.flags.is(Flags.Artifact) + def isArtifact: Boolean = + import reflect._ + sym.flags.is(Flags.Artifact) - def isLeftAssoc(d: Symbol): Boolean = !d.name.endsWith(":") + def isLeftAssoc: Boolean = !sym.name.endsWith(":") - def extendedSymbol: Option[ValDef] = + def extendedSymbol: Option[reflect.ValDef] = + import reflect.* Option.when(sym.isExtensionMethod){ val termParamss = sym.tree.asInstanceOf[DefDef].termParamss - if isLeftAssoc(sym) || termParamss.size == 1 then termParamss(0).params(0) + if sym.isLeftAssoc || termParamss.size == 1 then termParamss(0).params(0) else termParamss(1).params(0) } + end extension + +end SymOps + +// TODO find a better way to handle this cache and move the methods to SymOps +class SymOpsWithLinkCache: + import SymOps.* + + private val externalLinkCache: scala.collection.mutable.Map[AbstractFile, Option[ExternalDocLink]] = MMap() + + extension (using Quotes)(sym: reflect.Symbol) + private def constructPath(location: Seq[String], anchor: Option[String], link: ExternalDocLink): String = + import reflect.* val extension = ".html" val docURL = link.documentationUrl.toString def constructPathForJavadoc: String = @@ -154,6 +183,7 @@ class SymOps[Q <: Quotes](val q: Q) extends JavadocAnchorCreator with Scaladoc2A // TODO #22 make sure that DRIs are unique plus probably reuse semantic db code? def dri(using dctx: DocContext): DRI = + import reflect.* if sym == Symbol.noSymbol then topLevelDri else if sym.isValDef && sym.moduleClass.exists then sym.moduleClass.dri else @@ -170,9 +200,9 @@ class SymOps[Q <: Quotes](val q: Q) extends JavadocAnchorCreator with Scaladoc2A val location = sym.packageNameSplitted ++ className val externalLink = { - import q.reflect._ + import reflect._ import dotty.tools.dotc - given ctx: dotc.core.Contexts.Context = q.asInstanceOf[scala.quoted.runtime.impl.QuotesImpl].ctx + given ctx: dotc.core.Contexts.Context = quotes.asInstanceOf[scala.quoted.runtime.impl.QuotesImpl].ctx val csym = sym.asInstanceOf[dotc.core.Symbols.Symbol] val extLink = if externalLinkCache.contains(csym.associatedFile) then externalLinkCache(csym.associatedFile) else { @@ -181,7 +211,7 @@ class SymOps[Q <: Quotes](val q: Q) extends JavadocAnchorCreator with Scaladoc2A externalLinkCache += (csym.associatedFile -> calculatedLink) calculatedLink } - extLink.map(link => constructPath(location, anchor, link)) + extLink.map(link => sym.constructPath(location, anchor, link)) } DRI( @@ -193,7 +223,7 @@ class SymOps[Q <: Quotes](val q: Q) extends JavadocAnchorCreator with Scaladoc2A s"${sym.name}${sym.fullName}/${sym.signature.resultSig}/[${sym.signature.paramSigs.mkString("/")}]" ) - def driInContextOfInheritingParent(par: Symbol)(using dctx: DocContext): DRI = sym.dri.copy( + def driInContextOfInheritingParent(par: reflect.Symbol)(using dctx: DocContext): DRI = sym.dri.copy( location = par.dri.location, externalLink = None ) diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/SyntheticSupport.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/SyntheticSupport.scala index 28440b066fa7..fe8b94817e3e 100644 --- a/scaladoc/src/dotty/tools/scaladoc/tasty/SyntheticSupport.scala +++ b/scaladoc/src/dotty/tools/scaladoc/tasty/SyntheticSupport.scala @@ -3,48 +3,53 @@ package tasty import scala.quoted._ -trait SyntheticsSupport: - self: TastyParser => +object SyntheticsSupport: - import qctx.reflect._ + extension (using Quotes)(t: reflect.TypeRepr) + def isTupleType: Boolean = t.hackIsTupleType(t) - extension (t: TypeRepr) - def isTupleType: Boolean = hackIsTupleType(using qctx)(t) + def isCompiletimeAppliedType: Boolean = t.hackIsCompiletimeAppliedType(t) - def isCompiletimeAppliedType: Boolean = hackIsCompiletimeAppliedType(using qctx)(t) - - def hackIsTupleType(using Quotes)(rtpe: qctx.reflect.TypeRepr): Boolean = + private def hackIsTupleType(rtpe: reflect.TypeRepr): Boolean = import dotty.tools.dotc - given ctx: dotc.core.Contexts.Context = qctx.asInstanceOf[scala.quoted.runtime.impl.QuotesImpl].ctx + given ctx: dotc.core.Contexts.Context = quotes.asInstanceOf[scala.quoted.runtime.impl.QuotesImpl].ctx val tpe = rtpe.asInstanceOf[dotc.core.Types.Type] ctx.definitions.isTupleType(tpe) - def hackIsCompiletimeAppliedType(using Quotes)(rtpe: qctx.reflect.TypeRepr): Boolean = + private def hackIsCompiletimeAppliedType(rtpe: reflect.TypeRepr): Boolean = import dotty.tools.dotc - given ctx: dotc.core.Contexts.Context = qctx.asInstanceOf[scala.quoted.runtime.impl.QuotesImpl].ctx + given ctx: dotc.core.Contexts.Context = quotes.asInstanceOf[scala.quoted.runtime.impl.QuotesImpl].ctx val tpe = rtpe.asInstanceOf[dotc.core.Types.Type] ctx.definitions.isCompiletimeAppliedType(tpe.typeSymbol) + end extension - extension (s: Symbol) - def isSyntheticFunc: Boolean = s.flags.is(Flags.Synthetic) || s.flags.is(Flags.FieldAccessor) || isDefaultHelperMethod + extension (using Quotes)(s: reflect.Symbol) + def isSyntheticFunc: Boolean = + import reflect._ + s.flags.is(Flags.Synthetic) || s.flags.is(Flags.FieldAccessor) || s.isDefaultHelperMethod def isSuperBridgeMethod: Boolean = s.name.contains("$super$") def isDefaultHelperMethod: Boolean = ".*\\$default\\$\\d+$".r.matches(s.name) - def isOpaque: Boolean = s.flags.is(Flags.Opaque) + def isOpaque: Boolean = + import reflect._ + s.flags.is(Flags.Opaque) + + def isInfix: Boolean = hackIsInfix(s) - def isInfix: Boolean = hackIsInfix(using qctx)(s) + def getmembers: List[reflect.Symbol] = hackGetmembers(s) - def getmembers: List[Symbol] = hackGetmembers(using qctx)(s) + end extension - def isValidPos(pos: Position) = - if hackExists(using qctx)(pos) then pos.start != pos.end else false + def isValidPos(using Quotes)(pos: reflect.Position) = + if hackExists(pos) then pos.start != pos.end else false - def isSyntheticField(c: Symbol) = + def isSyntheticField(using Quotes)(c: reflect.Symbol) = + import reflect._ c.flags.is(Flags.CaseAccessor) || (c.flags.is(Flags.Module) && !c.flags.is(Flags.Given)) - def constructorWithoutParamLists(c: ClassDef): Boolean = + def constructorWithoutParamLists(using Quotes)(c: reflect.ClassDef): Boolean = !isValidPos(c.constructor.pos) || { val end = c.constructor.pos.end val typesEnd = c.constructor.leadingTypeParams.lastOption.fold(end - 1)(_.pos.end) @@ -53,10 +58,10 @@ trait SyntheticsSupport: } // TODO: #49 Remove it after TASTY-Reflect release with published flag Extension - def hackIsInfix(using Quotes)(rsym: qctx.reflect.Symbol): Boolean = { - import qctx.reflect._ + private def hackIsInfix(using Quotes)(rsym: reflect.Symbol): Boolean = { + import reflect._ import dotty.tools.dotc - given ctx: dotc.core.Contexts.Context = qctx.asInstanceOf[scala.quoted.runtime.impl.QuotesImpl].ctx + given ctx: dotc.core.Contexts.Context = quotes.asInstanceOf[scala.quoted.runtime.impl.QuotesImpl].ctx val sym = rsym.asInstanceOf[dotc.core.Symbols.Symbol] ctx.definitions.isInfix(sym) } @@ -64,10 +69,10 @@ trait SyntheticsSupport: They are valdefs that describe case companion objects and cases from enum. TASTY crashed when calling _.tree on them. */ - def hackGetmembers(using Quotes)(rsym: qctx.reflect.Symbol): List[qctx.reflect.Symbol] = { - import qctx.reflect._ + private def hackGetmembers(using Quotes)(rsym: reflect.Symbol): List[reflect.Symbol] = { + import reflect._ import dotty.tools.dotc - given ctx: dotc.core.Contexts.Context = qctx.asInstanceOf[scala.quoted.runtime.impl.QuotesImpl].ctx + given ctx: dotc.core.Contexts.Context = quotes.asInstanceOf[scala.quoted.runtime.impl.QuotesImpl].ctx val sym = rsym.asInstanceOf[dotc.core.Symbols.Symbol] sym.typeRef.appliedTo(sym.typeParams.map(_.typeRef)).allMembers.iterator.map(_.symbol) .collect { @@ -78,10 +83,10 @@ trait SyntheticsSupport: }.toList } - def hackGetSupertypes(using Quotes)(rdef: qctx.reflect.ClassDef) = { - import qctx.reflect._ + private def hackGetSupertypes(using Quotes)(rdef: reflect.ClassDef) = { + import reflect._ import dotty.tools.dotc - given dotc.core.Contexts.Context = qctx.asInstanceOf[scala.quoted.runtime.impl.QuotesImpl].ctx + given dotc.core.Contexts.Context = quotes.asInstanceOf[scala.quoted.runtime.impl.QuotesImpl].ctx val classdef = rdef.asInstanceOf[dotc.ast.tpd.TypeDef] val ref = classdef.symbol.info.asInstanceOf[dotc.core.Types.ClassInfo].appliedRef val baseTypes: List[(dotc.core.Symbols.Symbol, dotc.core.Types.Type)] = @@ -89,28 +94,28 @@ trait SyntheticsSupport: baseTypes.asInstanceOf[List[(Symbol, TypeRepr)]] } - def hackExists(using Quotes)(rpos: qctx.reflect.Position) = { - import qctx.reflect._ + private def hackExists(using Quotes)(rpos: reflect.Position) = { + import reflect._ import dotty.tools.dotc import dotty.tools.dotc.util.Spans._ - given dotc.core.Contexts.Context = qctx.asInstanceOf[scala.quoted.runtime.impl.QuotesImpl].ctx + given dotc.core.Contexts.Context = quotes.asInstanceOf[scala.quoted.runtime.impl.QuotesImpl].ctx val pos = rpos.asInstanceOf[dotc.util.SourcePosition] pos.exists } - def getSupertypes(using Quotes)(c: ClassDef) = hackGetSupertypes(c).tail + def getSupertypes(using Quotes)(c: reflect.ClassDef) = hackGetSupertypes(c).tail - def typeForClass(c: ClassDef): TypeRepr = - import qctx.reflect._ + def typeForClass(using Quotes)(c: reflect.ClassDef): reflect.TypeRepr = + import reflect._ import dotty.tools.dotc - given dotc.core.Contexts.Context = qctx.asInstanceOf[scala.quoted.runtime.impl.QuotesImpl].ctx + given dotc.core.Contexts.Context = quotes.asInstanceOf[scala.quoted.runtime.impl.QuotesImpl].ctx val cSym = c.symbol.asInstanceOf[dotc.core.Symbols.Symbol] cSym.typeRef.appliedTo(cSym.typeParams.map(_.typeRef)).asInstanceOf[TypeRepr] - def memberInfo(c: ClassDef, symbol: Symbol): TypeRepr = - import qctx.reflect._ + def memberInfo(using Quotes)(c: reflect.ClassDef, symbol: reflect.Symbol): reflect.TypeRepr = + import reflect._ import dotty.tools.dotc - given dotc.core.Contexts.Context = qctx.asInstanceOf[scala.quoted.runtime.impl.QuotesImpl].ctx + given dotc.core.Contexts.Context = quotes.asInstanceOf[scala.quoted.runtime.impl.QuotesImpl].ctx typeForClass(c).asInstanceOf[dotc.core.Types.Type] .memberInfo(symbol.asInstanceOf[dotc.core.Symbols.Symbol]) .asInstanceOf[TypeRepr] diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/TastyParser.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/TastyParser.scala index 0e5871138926..69d83e126b36 100644 --- a/scaladoc/src/dotty/tools/scaladoc/tasty/TastyParser.scala +++ b/scaladoc/src/dotty/tools/scaladoc/tasty/TastyParser.scala @@ -6,7 +6,7 @@ import java.util.regex.Pattern import scala.util.{Try, Success, Failure} import scala.tasty.inspector.DocTastyInspector -import scala.quoted.Quotes +import scala.quoted._ import dotty.tools.dotc @@ -17,6 +17,9 @@ import dotty.tools.scaladoc.tasty.comments.Comment import java.nio.file.Paths import java.nio.file.Files +import SymOps._ +import ScaladocSupport._ + /** Responsible for collectively inspecting all the Tasty files we're interested in. * * Delegates most of the work to [[TastyParser]] [[dotty.tools.scaladoc.tasty.TastyParser]]. @@ -26,22 +29,22 @@ case class ScaladocTastyInspector()(using ctx: DocContext) extends DocTastyInspe private val topLevels = Seq.newBuilder[(String, Member)] private var rootDoc: Option[Comment] = None - def processCompilationUnit(using quotes: Quotes)(root: quotes.reflect.Tree): Unit = () + def processCompilationUnit(using Quotes)(root: reflect.Tree): Unit = () - override def postProcess(using q: Quotes): Unit = + override def postProcess(using Quotes): Unit = // hack into the compiler to get a list of all top-level trees // in principle, to do this, one would collect trees in processCompilationUnit // however, path-dependent types disallow doing so w/o using casts - inline def hackForeachTree(thunk: q.reflect.Tree => Unit): Unit = - given dctx: dotc.core.Contexts.Context = q.asInstanceOf[scala.quoted.runtime.impl.QuotesImpl].ctx + inline def hackForeachTree(thunk: reflect.Tree => Unit): Unit = + given dctx: dotc.core.Contexts.Context = quotes.asInstanceOf[scala.quoted.runtime.impl.QuotesImpl].ctx dctx.run.units.foreach { compilationUnit => // mirrors code from TastyInspector - thunk(compilationUnit.tpdTree.asInstanceOf[q.reflect.Tree]) + thunk(compilationUnit.tpdTree.asInstanceOf[reflect.Tree]) } - val symbolsToSkip: Set[q.reflect.Symbol] = + val symbolsToSkip: Set[reflect.Symbol] = ctx.args.identifiersToSkip.flatMap { ref => - val qrSymbol = q.reflect.Symbol + val qrSymbol = reflect.Symbol Try(qrSymbol.requiredPackage(ref)).orElse(Try(qrSymbol.requiredClass(ref))) match { case Success(sym) => Some(sym) case Failure(err) => @@ -65,20 +68,20 @@ case class ScaladocTastyInspector()(using ctx: DocContext) extends DocTastyInspe None } - def isSkipped(sym: q.reflect.Symbol): Boolean = - def isSkippedById(sym: q.reflect.Symbol): Boolean = + def isSkipped(sym: reflect.Symbol): Boolean = + def isSkippedById(sym: reflect.Symbol): Boolean = if !sym.exists then false else symbolsToSkip.contains(sym) || isSkipped(sym.owner) - def isSkippedByRx(sym: q.reflect.Symbol): Boolean = + def isSkippedByRx(sym: reflect.Symbol): Boolean = val symStr = sym.fullName patternsToSkip.exists(p => p.matcher(symStr).matches()) isSkippedById(sym) || isSkippedByRx(sym) - val parser = new TastyParser(q, this)(isSkipped) + val parser = new TastyParser(quotes, this)(isSkipped) def driFor(link: String): Option[DRI] = - val symOps = new SymOps[q.type](q) + val symOps = new SymOpsWithLinkCache import symOps._ Try(QueryParser(link).readQuery()).toOption.flatMap(query => MemberLookup.lookupOpt(query, None).map { @@ -110,7 +113,7 @@ case class ScaladocTastyInspector()(using ctx: DocContext) extends DocTastyInspe import parser.qctx.reflect._ def root(s: Symbol): Symbol = if s.owner.isNoSymbol then s else root(s.owner) val topLevelPck = root(tree.symbol) - rootDoc = Some(parser.parseCommentString(content, topLevelPck, None)) + rootDoc = Some(parseCommentString(using parser.qctx, summon[DocContext])(content, topLevelPck, None)) } hackForeachTree { root => @@ -175,9 +178,11 @@ case class TastyParser( isSkipped: qctx.reflect.Symbol => Boolean )( using val ctx: DocContext -) extends ScaladocSupport with BasicSupport with TypesSupport with ClassLikeSupport with SyntheticsSupport with PackageSupport with NameNormalizer: +) extends BasicSupport with TypesSupport with ClassLikeSupport with PackageSupport: import qctx.reflect._ + private given qctx.type = qctx + def processTree[T](tree: Tree)(op: => T): Option[T] = try Option(op) catch case e: Exception => report.warning(throwableToString(e), tree.pos) diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/TypesSupport.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/TypesSupport.scala index af5509768aaa..ca61a47ef5b7 100644 --- a/scaladoc/src/dotty/tools/scaladoc/tasty/TypesSupport.scala +++ b/scaladoc/src/dotty/tools/scaladoc/tasty/TypesSupport.scala @@ -3,14 +3,21 @@ package tasty import collection.JavaConverters._ +import scala.quoted._ + +import NameNormalizer._ +import SyntheticsSupport._ + trait TypesSupport: self: TastyParser => - import qctx.reflect._ type DocSignaturePart = String | Link type DocSignature = List[DocSignaturePart] - def getGivenInstance(method: DefDef): Option[DocSignature] = + def getGivenInstance(method: qctx.reflect.DefDef): Option[DocSignature] = + import qctx.reflect._ + given qctx.type = qctx + def extractTypeSymbol(t: Tree): Option[Symbol] = t match case tpeTree: TypeTree => inner(tpeTree.tpe) @@ -37,15 +44,16 @@ trait TypesSupport: }.flatten.map(_.asSignature) given TreeSyntax: AnyRef with - extension (tpeTree: Tree) + extension (using Quotes)(tpeTree: reflect.Tree) def asSignature: DocSignature = + import reflect._ tpeTree match case TypeBoundsTree(low, high) => typeBoundsTreeOfHigherKindedType(low.tpe, high.tpe) case tpeTree: TypeTree => inner(tpeTree.tpe) case term: Term => inner(term.tpe) given TypeSyntax: AnyRef with - extension (tpe: TypeRepr) + extension (using Quotes)(tpe: reflect.TypeRepr) def asSignature: DocSignature = inner(tpe) @@ -53,7 +61,7 @@ trait TypesSupport: private def texts(str: String): DocSignature = List(text(str)) - private def link(symbol: Symbol): DocSignature = + private def link(using Quotes)(symbol: reflect.Symbol): DocSignature = val suffix = if symbol.isValDef then texts(".type") else Nil Link(symbol.normalizedName, symbol.dri) :: suffix @@ -61,14 +69,16 @@ trait TypesSupport: case List(single) => single case other => other.reduce((r, e) => r ++ texts(", ") ++ e) - private def isRepeatedAnnotation(term: Term) = + private def isRepeatedAnnotation(using Quotes)(term: reflect.Term) = + import reflect._ term.tpe match case t: TypeRef => t.name == "Repeated" && t.qualifier.match case ThisType(tref: TypeRef) if tref.name == "internal" => true case _ => false case _ => false - private def isRepeated(typeRepr: TypeRepr) = + private def isRepeated(using Quotes)(typeRepr: reflect.TypeRepr) = + import reflect._ typeRepr match case t: TypeRef => t.name == "" && t.qualifier.match case ThisType(tref: TypeRef) if tref.name == "scala" => true @@ -76,7 +86,8 @@ trait TypesSupport: case _ => false // TODO #23 add support for all types signatures that makes sense - private def inner(tp: TypeRepr): DocSignature = + private def inner(using Quotes)(tp: reflect.TypeRepr): DocSignature = + import reflect._ def noSupported(name: String): DocSignature = println(s"WARN: Unsupported type: $name: ${tp.show}") List(text(s"Unsupported[$name]")) @@ -261,8 +272,9 @@ trait TypesSupport: case RecursiveType(tp) => inner(tp) - private def typeBound(t: TypeRepr, low: Boolean) = - val ignore = if(low) t.typeSymbol == defn.NothingClass else t.typeSymbol == defn.AnyClass + private def typeBound(using Quotes)(t: reflect.TypeRepr, low: Boolean) = + import reflect._ + val ignore = if (low) t.typeSymbol == defn.NothingClass else t.typeSymbol == defn.AnyClass val prefix = text(if low then " >: " else " <: ") t match { case l: TypeLambda => prefix :: texts("(") ++ inner(l) ++ texts(")") @@ -271,7 +283,8 @@ trait TypesSupport: case _ => Nil } - private def typeBoundsTreeOfHigherKindedType(low: TypeRepr, high: TypeRepr) = + private def typeBoundsTreeOfHigherKindedType(using Quotes)(low: reflect.TypeRepr, high: reflect.TypeRepr) = + import reflect._ def regularTypeBounds(low: TypeRepr, high: TypeRepr) = typeBound(low, low = true) ++ typeBound(high, low = false) high.match diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/comments/Comments.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/comments/Comments.scala index c60187c1b8b9..d9199864a407 100644 --- a/scaladoc/src/dotty/tools/scaladoc/tasty/comments/Comments.scala +++ b/scaladoc/src/dotty/tools/scaladoc/tasty/comments/Comments.scala @@ -12,7 +12,8 @@ import com.vladsch.flexmark.util.options.MutableDataSet import scala.quoted._ import dotty.tools.scaladoc.tasty.comments.wiki.Paragraph import dotty.tools.scaladoc.DocPart -import dotty.tools.scaladoc.tasty.SymOps +import dotty.tools.scaladoc.tasty.SymOpsWithLinkCache +import collection.JavaConverters._ import collection.JavaConverters._ class Repr(val qctx: Quotes)(val sym: qctx.reflect.Symbol) @@ -80,10 +81,11 @@ abstract class MarkupConversion[T](val repr: Repr)(using DocContext) { val qctx: repr.qctx.type = if repr == null then null else repr.qctx // TODO why we do need null? val owner: qctx.reflect.Symbol = if repr == null then null.asInstanceOf[qctx.reflect.Symbol] else repr.sym + private given qctx.type = qctx - object SymOps extends SymOps[qctx.type](qctx) - export SymOps.dri - export SymOps.driInContextOfInheritingParent + object SymOpsWithLinkCache extends SymOpsWithLinkCache + export SymOpsWithLinkCache.dri + export SymOpsWithLinkCache.driInContextOfInheritingParent def resolveLink(queryStr: String): DocLink = if SchemeUri.matches(queryStr) then DocLink.ToURL(queryStr) diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/comments/MemberLookup.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/comments/MemberLookup.scala index da88f58eb9e8..14f14cbedbd1 100644 --- a/scaladoc/src/dotty/tools/scaladoc/tasty/comments/MemberLookup.scala +++ b/scaladoc/src/dotty/tools/scaladoc/tasty/comments/MemberLookup.scala @@ -1,28 +1,29 @@ package dotty.tools.scaladoc -package tasty.comments +package tasty +package comments import scala.quoted._ trait MemberLookup { def memberLookupResult(using Quotes)( - symbol: quotes.reflect.Symbol, + symbol: reflect.Symbol, label: String, - inheritingParent: Option[quotes.reflect.Symbol] = None - ): (quotes.reflect.Symbol, String, Option[quotes.reflect.Symbol]) = + inheritingParent: Option[reflect.Symbol] = None + ): (reflect.Symbol, String, Option[reflect.Symbol]) = (symbol, label, inheritingParent) def lookup(using Quotes, DocContext)( query: Query, - owner: quotes.reflect.Symbol, - ): Option[(quotes.reflect.Symbol, String, Option[quotes.reflect.Symbol])] = lookupOpt(query, Some(owner)) + owner: reflect.Symbol, + ): Option[(reflect.Symbol, String, Option[reflect.Symbol])] = lookupOpt(query, Some(owner)) def lookupOpt(using Quotes, DocContext)( query: Query, - ownerOpt: Option[quotes.reflect.Symbol], - ): Option[(quotes.reflect.Symbol, String, Option[quotes.reflect.Symbol])] = + ownerOpt: Option[reflect.Symbol], + ): Option[(reflect.Symbol, String, Option[reflect.Symbol])] = try - import quotes.reflect._ + import reflect._ def nearestClass(sym: Symbol): Symbol = if sym.isClassDef then sym else nearestClass(sym.owner) @@ -90,8 +91,8 @@ trait MemberLookup { report.warn(msg, e) None - private def hackMembersOf(using Quotes)(rsym: quotes.reflect.Symbol) = { - import quotes.reflect._ + private def hackMembersOf(using Quotes)(rsym: reflect.Symbol) = { + import reflect._ import dotty.tools.dotc given dotc.core.Contexts.Context = quotes.asInstanceOf[scala.quoted.runtime.impl.QuotesImpl].ctx val sym = rsym.asInstanceOf[dotc.core.Symbols.Symbol] @@ -103,7 +104,7 @@ trait MemberLookup { members.asInstanceOf[Iterator[Symbol]] } - private def hackIsNotAbsent(using Quotes)(rsym: quotes.reflect.Symbol) = + private def hackIsNotAbsent(using Quotes)(rsym: reflect.Symbol) = import dotty.tools.dotc given dotc.core.Contexts.Context = quotes.asInstanceOf[scala.quoted.runtime.impl.QuotesImpl].ctx val sym = rsym.asInstanceOf[dotc.core.Symbols.Symbol] @@ -115,9 +116,9 @@ trait MemberLookup { private def localLookup(using Quotes)( sel: MemberLookup.Selector, - owner: quotes.reflect.Symbol - ): Iterator[quotes.reflect.Symbol] = { - import quotes.reflect._ + owner: reflect.Symbol + ): Iterator[reflect.Symbol] = { + import reflect._ def findMatch(syms: Iterator[Symbol]): Iterator[Symbol] = { def matches(s: Symbol): Boolean = @@ -173,9 +174,9 @@ trait MemberLookup { } private def downwardLookup(using Quotes)( - query: List[String], owner: quotes.reflect.Symbol - ): Option[(quotes.reflect.Symbol, Option[quotes.reflect.Symbol])] = { - import quotes.reflect._ + query: List[String], owner: reflect.Symbol + ): Option[(reflect.Symbol, Option[reflect.Symbol])] = { + import reflect._ query match { case Nil => None case q :: Nil => @@ -193,7 +194,7 @@ trait MemberLookup { res match { case None => None case Some(sym) => - val externalOwner: Option[quotes.reflect.Symbol] = + val externalOwner: Option[reflect.Symbol] = if owner eq sym.owner then None else if owner.flags.is(Flags.Module) then Some(owner.moduleClass) else if owner.isClassDef then Some(owner) diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/reflect.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/reflect.scala new file mode 100644 index 000000000000..b48519e29d28 --- /dev/null +++ b/scaladoc/src/dotty/tools/scaladoc/tasty/reflect.scala @@ -0,0 +1,7 @@ +package dotty.tools.scaladoc +package tasty + +import scala.quoted._ + +/** Shorthand for `quotes.reflect` */ +transparent inline def reflect(using inline q: Quotes): q.reflect.type = q.reflect diff --git a/scaladoc/test/dotty/tools/scaladoc/tasty/comments/CommentExpanderTests.scala b/scaladoc/test/dotty/tools/scaladoc/tasty/comments/CommentExpanderTests.scala index 63bb4fb21f03..097401576069 100644 --- a/scaladoc/test/dotty/tools/scaladoc/tasty/comments/CommentExpanderTests.scala +++ b/scaladoc/test/dotty/tools/scaladoc/tasty/comments/CommentExpanderTests.scala @@ -1,5 +1,6 @@ package dotty.tools.scaladoc -package tasty.comments +package tasty +package comments import scala.quoted._ @@ -9,25 +10,25 @@ import dotty.tools.scaladoc.tasty.util._ import dotty.tools.scaladoc.tasty.TastyParser class CommentExpanderTests { - def check(using quoted.Quotes)(): Unit = + def check(using Quotes)(): Unit = assertCommentEquals( - qr.Symbol.requiredClass("tests.B").memberMethod("otherMethod").head, + reflect.Symbol.requiredClass("tests.B").memberMethod("otherMethod").head, "/** This is my foo: Bar, actually. */", ) assertCommentEquals( - qr.Symbol.requiredClass("tests.C"), + reflect.Symbol.requiredClass("tests.C"), "/** This is foo: Foo expanded. */", ) assertCommentEquals( - qr.Symbol.requiredModule("tests.O").memberMethod("method").head, + reflect.Symbol.requiredModule("tests.O").memberMethod("method").head, "/** This is foo: O's foo. */", ) def assertCommentEquals( - using quoted.Quotes + using Quotes )( - rsym: quotes.reflect.Symbol, + rsym: reflect.Symbol, str: String ): Unit = import dotty.tools.dotc @@ -41,13 +42,12 @@ class CommentExpanderTests { import scala.tasty.inspector.OldTastyInspector class Inspector extends OldTastyInspector: - def processCompilationUnit(using quoted.Quotes)(root: quotes.reflect.Tree): Unit = () + def processCompilationUnit(using Quotes)(root: reflect.Tree): Unit = () - override def postProcess(using quoted.Quotes): Unit = + override def postProcess(using Quotes): Unit = check() Inspector().inspectTastyFiles(TestUtils.listOurClasses()) } - private def qr(using quoted.Quotes): quotes.reflect.type = quotes.reflect }