From 01329075452ac0002381d46621b99fcfcf2684ab Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Filip=20Zyba=C5=82a?= Date: Fri, 8 Apr 2022 13:36:13 +0200 Subject: [PATCH 1/7] Remove isInfix method --- .../dotty/tools/scaladoc/tasty/SyntheticSupport.scala | 10 ---------- 1 file changed, 10 deletions(-) diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/SyntheticSupport.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/SyntheticSupport.scala index 735d9c74d733..a509127608bd 100644 --- a/scaladoc/src/dotty/tools/scaladoc/tasty/SyntheticSupport.scala +++ b/scaladoc/src/dotty/tools/scaladoc/tasty/SyntheticSupport.scala @@ -29,8 +29,6 @@ object SyntheticsSupport: import reflect._ s.flags.is(Flags.Opaque) - def isInfix: Boolean = hackIsInfix(s) - def getmembers: List[reflect.Symbol] = hackGetmembers(s) end extension @@ -50,14 +48,6 @@ object SyntheticsSupport: c.constructor.leadingTypeParams.nonEmpty && end <= typesEnd + 1 } - // TODO: #49 Remove it after TASTY-Reflect release with published flag Extension - private def hackIsInfix(using Quotes)(rsym: reflect.Symbol): Boolean = { - import reflect._ - import dotty.tools.dotc - 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) - } /* We need there to filter out symbols with certain flagsets, because these symbols come from compiler and TASTY can't handle them well. They are valdefs that describe case companion objects and cases from enum. TASTY crashed when calling _.tree on them. From 0c77c36d38d6575171f8edcc89a1fdffb81aec03 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Filip=20Zyba=C5=82a?= Date: Fri, 8 Apr 2022 16:35:27 +0200 Subject: [PATCH 2/7] Remove Position existence check in Scaladoc --- .../scaladoc/tasty/ClassLikeSupport.scala | 9 ++- .../scaladoc/tasty/SyntheticSupport.scala | 14 +---- .../tools/scaladoc/tasty/TastyParser.scala | 56 +++++++++++-------- 3 files changed, 40 insertions(+), 39 deletions(-) diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala index 7d5886193c6b..5acbfd440fe9 100644 --- a/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala +++ b/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala @@ -96,7 +96,9 @@ trait ClassLikeSupport: getSupertypesGraph(LinkToType(selfSignature, classDef.symbol.dri, bareClasslikeKind(classDef.symbol)), unpackTreeToClassDef(classDef).parents) ) - val baseMember = mkMember(classDef.symbol, kindForClasslike(classDef), selfSignature)( + val kind = if intrinsicClassDefs.contains(classDef.symbol) then Kind.Class(Nil, Nil) else kindForClasslike(classDef) + + val baseMember = mkMember(classDef.symbol, kind, selfSignature)( modifiers = modifiers, graph = graph, deprecated = classDef.symbol.isDeprecated(), @@ -253,8 +255,9 @@ trait ClassLikeSupport: } def getParentsAsTreeSymbolTuples: List[(Tree, Symbol)] = - for - parentTree <- c.parents if isValidPos(parentTree.pos) // We assume here that order is correct + if noPosClassDefs.contains(c.symbol) then Nil + else for + parentTree <- c.parents if parentTree.pos.start != parentTree.pos.end // We assume here that order is correct parentSymbol = parentTree match case t: TypeTree => t.tpe.typeSymbol case tree if tree.symbol.isClassConstructor => tree.symbol.owner diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/SyntheticSupport.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/SyntheticSupport.scala index a509127608bd..c21c6f259c13 100644 --- a/scaladoc/src/dotty/tools/scaladoc/tasty/SyntheticSupport.scala +++ b/scaladoc/src/dotty/tools/scaladoc/tasty/SyntheticSupport.scala @@ -33,15 +33,12 @@ object SyntheticsSupport: end extension - def isValidPos(using Quotes)(pos: reflect.Position) = - if hackExists(pos) then pos.start != pos.end else false - 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(using Quotes)(c: reflect.ClassDef): Boolean = - !isValidPos(c.constructor.pos) || { + c.constructor.pos.start == c.constructor.pos.end || { val end = c.constructor.pos.end val typesEnd = c.constructor.leadingTypeParams.lastOption.fold(end - 1)(_.pos.end) val classDefTree = c.constructor.show @@ -77,15 +74,6 @@ object SyntheticsSupport: baseTypes.asInstanceOf[List[(Symbol, TypeRepr)]] } - 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 = quotes.asInstanceOf[scala.quoted.runtime.impl.QuotesImpl].ctx - val pos = rpos.asInstanceOf[dotc.util.SourcePosition] - pos.exists - } - def getSupertypes(using Quotes)(c: reflect.ClassDef) = hackGetSupertypes(c).tail def typeForClass(using Quotes)(c: reflect.ClassDef): reflect.TypeRepr = diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/TastyParser.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/TastyParser.scala index 76416c793b1d..b78dab1e28df 100644 --- a/scaladoc/src/dotty/tools/scaladoc/tasty/TastyParser.scala +++ b/scaladoc/src/dotty/tools/scaladoc/tasty/TastyParser.scala @@ -123,27 +123,17 @@ case class ScaladocTastyInspector()(using ctx: DocContext) extends DocTastyInspe topLevels ++= parser.parseRootTree(treeRoot) } - val defn = ctx.compilerContext.definitions - if ctx.args.documentSyntheticTypes then - val intrinsicClassDefs = Seq( - defn.AnyClass, - defn.MatchableClass, - defn.AnyKindClass, - defn.AnyValClass, - defn.NullClass, - defn.NothingClass, - defn.SingletonClass, - defn.andType, - defn.orType, - ).map { s => - "scala" -> s.asInstanceOf[parser.qctx.reflect.Symbol].tree.match { - case cd: parser.qctx.reflect.ClassDef => parser.parseClasslike(cd) - case td: parser.qctx.reflect.TypeDef => parser.parseTypeDef(td) - } + import parser.qctx.reflect._ + val intrinsicTypeDefs = parser.intrinsicTypeDefs.toSeq.map { s => + "scala" -> parser.parseTypeDef(s.tree.asInstanceOf[TypeDef]) + } + val intrinsicClassDefs = parser.intrinsicClassDefs.toSeq.map { s => + "scala" -> parser.parseClasslike(s.tree.asInstanceOf[ClassDef]) } topLevels ++= intrinsicClassDefs - val scalaPckg = defn.ScalaPackageVal.asInstanceOf[parser.qctx.reflect.Symbol] + topLevels ++= intrinsicTypeDefs + val scalaPckg = defn.ScalaPackage given parser.qctx.type = parser.qctx topLevels += "scala" -> Member(scalaPckg.fullName, scalaPckg.dri, Kind.Package) topLevels += mergeAnyRefAliasAndObject(parser) @@ -167,12 +157,13 @@ case class ScaladocTastyInspector()(using ctx: DocContext) extends DocTastyInspe }.toList -> rootDoc def mergeAnyRefAliasAndObject(parser: TastyParser) = - val defn = ctx.compilerContext.definitions - val oM = parser.parseClasslike(defn.ObjectClass.asInstanceOf[parser.qctx.reflect.Symbol].tree.asInstanceOf[parser.qctx.reflect.ClassDef]) - val aM = parser.parseTypeDef(defn.AnyRefAlias.asInstanceOf[parser.qctx.reflect.Symbol].tree.asInstanceOf[parser.qctx.reflect.TypeDef]) + import parser.qctx.reflect._ + val javaLangObjectDef = defn.ObjectClass.tree.asInstanceOf[ClassDef] + val objectMembers = parser.extractPatchedMembers(javaLangObjectDef) + val aM = parser.parseTypeDef(defn.AnyRefClass.tree.asInstanceOf[TypeDef]) "scala" -> aM.copy( - kind = oM.kind, - members = oM.members + kind = Kind.Class(Nil, Nil), + members = objectMembers ) /** Parses a single Tasty compilation unit. */ case class TastyParser( @@ -187,6 +178,25 @@ case class TastyParser( private given qctx.type = qctx + val intrinsicClassDefs = Set( + defn.AnyClass, + defn.MatchableClass, + defn.ScalaPackage.typeMember("AnyKind"), + defn.AnyValClass, + defn.NullClass, + defn.NothingClass, + defn.ScalaPackage.typeMember("Singleton"), + ) + + val noPosClassDefs = intrinsicClassDefs ++ Set( + defn.ObjectClass, + defn.AnyRefClass + ) + + val intrinsicTypeDefs = Set( + defn.ScalaPackage.typeMember("&"), + defn.ScalaPackage.typeMember("|"), + ) def processTree[T](tree: Tree)(op: => T): Option[T] = try Option(op) catch case e: Exception => report.warning(throwableToString(e), tree.pos) From c50ca10933eba19cc52d1e92310557dc3bab5e29 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Filip=20Zyba=C5=82a?= Date: Fri, 8 Apr 2022 16:44:23 +0200 Subject: [PATCH 3/7] Remove method finding supertypes in compiler internals --- .../tools/scaladoc/tasty/SyntheticSupport.scala | 14 ++------------ 1 file changed, 2 insertions(+), 12 deletions(-) diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/SyntheticSupport.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/SyntheticSupport.scala index c21c6f259c13..8fbabb8500b4 100644 --- a/scaladoc/src/dotty/tools/scaladoc/tasty/SyntheticSupport.scala +++ b/scaladoc/src/dotty/tools/scaladoc/tasty/SyntheticSupport.scala @@ -63,18 +63,8 @@ object SyntheticsSupport: }.toList } - private def hackGetSupertypes(using Quotes)(rdef: reflect.ClassDef) = { - import reflect._ - import dotty.tools.dotc - 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)] = - ref.baseClasses.map(b => b -> ref.baseType(b)) - baseTypes.asInstanceOf[List[(Symbol, TypeRepr)]] - } - - def getSupertypes(using Quotes)(c: reflect.ClassDef) = hackGetSupertypes(c).tail + def getSupertypes(using Quotes)(c: reflect.ClassDef) = + c.symbol.typeRef.baseClasses.map(b => b -> c.symbol.typeRef.baseType(b)).tail def typeForClass(using Quotes)(c: reflect.ClassDef): reflect.TypeRepr = import reflect._ From 632b0e47abd37ef5b9c839d8067b2641d786b9f7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Filip=20Zyba=C5=82a?= Date: Fri, 8 Apr 2022 16:53:17 +0200 Subject: [PATCH 4/7] Remove internal API usage from typeForClass --- .../src/dotty/tools/scaladoc/tasty/SyntheticSupport.scala | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/SyntheticSupport.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/SyntheticSupport.scala index 8fbabb8500b4..76d5ca51c2fb 100644 --- a/scaladoc/src/dotty/tools/scaladoc/tasty/SyntheticSupport.scala +++ b/scaladoc/src/dotty/tools/scaladoc/tasty/SyntheticSupport.scala @@ -67,11 +67,7 @@ object SyntheticsSupport: c.symbol.typeRef.baseClasses.map(b => b -> c.symbol.typeRef.baseType(b)).tail def typeForClass(using Quotes)(c: reflect.ClassDef): reflect.TypeRepr = - import reflect._ - import dotty.tools.dotc - 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] + c.symbol.typeRef.appliedTo(c.symbol.typeMembers.filter(_.isTypeParam).map(_.typeRef)) def memberInfo(using Quotes)(c: reflect.ClassDef, symbol: reflect.Symbol): reflect.TypeRepr = import reflect._ From fc2bf60df3b723c635f7bae134fe2fcbc49b29e3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Filip=20Zyba=C5=82a?= Date: Fri, 8 Apr 2022 16:56:30 +0200 Subject: [PATCH 5/7] Move hacky methods at the end of file --- .../scaladoc/tasty/SyntheticSupport.scala | 27 ++++++++++--------- 1 file changed, 14 insertions(+), 13 deletions(-) diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/SyntheticSupport.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/SyntheticSupport.scala index 76d5ca51c2fb..1c4375ba8ab9 100644 --- a/scaladoc/src/dotty/tools/scaladoc/tasty/SyntheticSupport.scala +++ b/scaladoc/src/dotty/tools/scaladoc/tasty/SyntheticSupport.scala @@ -49,19 +49,6 @@ object SyntheticsSupport: They are valdefs that describe case companion objects and cases from enum. TASTY crashed when calling _.tree on them. */ - private def hackGetmembers(using Quotes)(rsym: reflect.Symbol): List[reflect.Symbol] = { - import reflect._ - import dotty.tools.dotc - given ctx: dotc.core.Contexts.Context = quotes.asInstanceOf[scala.quoted.runtime.impl.QuotesImpl].ctx - val sym = rsym.asInstanceOf[dotc.core.Symbols.Symbol] - sym.namedType.allMembers.iterator.map(_.symbol) - .collect { - case sym if - (!sym.is(dotc.core.Flags.ModuleVal) || sym.is(dotc.core.Flags.Given)) && - !sym.flags.isAllOf(dotc.core.Flags.Enum | dotc.core.Flags.Case | dotc.core.Flags.JavaStatic) => - sym.asInstanceOf[Symbol] - }.toList - } def getSupertypes(using Quotes)(c: reflect.ClassDef) = c.symbol.typeRef.baseClasses.map(b => b -> c.symbol.typeRef.baseType(b)).tail @@ -76,3 +63,17 @@ object SyntheticsSupport: typeForClass(c).asInstanceOf[dotc.core.Types.Type] .memberInfo(symbol.asInstanceOf[dotc.core.Symbols.Symbol]) .asInstanceOf[TypeRepr] + + private def hackGetmembers(using Quotes)(rsym: reflect.Symbol): List[reflect.Symbol] = { + import reflect._ + import dotty.tools.dotc + given ctx: dotc.core.Contexts.Context = quotes.asInstanceOf[scala.quoted.runtime.impl.QuotesImpl].ctx + val sym = rsym.asInstanceOf[dotc.core.Symbols.Symbol] + sym.namedType.allMembers.iterator.map(_.symbol) + .collect { + case sym if + (!sym.is(dotc.core.Flags.ModuleVal) || sym.is(dotc.core.Flags.Given)) && + !sym.flags.isAllOf(dotc.core.Flags.Enum | dotc.core.Flags.Case | dotc.core.Flags.JavaStatic) => + sym.asInstanceOf[Symbol] + }.toList + } From 32dd051f79990fceb843c68dd4975d67a9c5cc89 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Filip=20Zyba=C5=82a?= Date: Fri, 8 Apr 2022 17:08:05 +0200 Subject: [PATCH 6/7] Remove isCompiletimeAppliedType method --- .../dotty/tools/scaladoc/tasty/SyntheticSupport.scala | 11 ----------- 1 file changed, 11 deletions(-) diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/SyntheticSupport.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/SyntheticSupport.scala index 1c4375ba8ab9..f04ef6689767 100644 --- a/scaladoc/src/dotty/tools/scaladoc/tasty/SyntheticSupport.scala +++ b/scaladoc/src/dotty/tools/scaladoc/tasty/SyntheticSupport.scala @@ -5,17 +5,6 @@ import scala.quoted._ object SyntheticsSupport: - extension (using Quotes)(t: reflect.TypeRepr) - - def isCompiletimeAppliedType: Boolean = t.hackIsCompiletimeAppliedType(t) - - private def hackIsCompiletimeAppliedType(rtpe: reflect.TypeRepr): Boolean = - import dotty.tools.dotc - 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 (using Quotes)(s: reflect.Symbol) def isSyntheticFunc: Boolean = import reflect._ From 1af2f94b79251c49aec3e49222bad060067f0b68 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Filip=20Zyba=C5=82a?= Date: Mon, 11 Apr 2022 10:12:53 +0200 Subject: [PATCH 7/7] Remove memberInfo usage --- .../tools/scaladoc/tasty/ClassLikeSupport.scala | 4 ++-- .../tools/scaladoc/tasty/SyntheticSupport.scala | 17 ++++------------- 2 files changed, 6 insertions(+), 15 deletions(-) diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala index 5acbfd440fe9..1e855e6e541a 100644 --- a/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala +++ b/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala @@ -485,7 +485,7 @@ trait ClassLikeSupport: def unwrapMemberInfo(c: ClassDef, symbol: Symbol): MemberInfo = - val baseTypeRepr = memberInfo(c, symbol) + val baseTypeRepr = typeForClass(c).memberType(symbol) def isSyntheticEvidence(name: String) = if !name.startsWith(NameKinds.EvidenceParamName.separator) then false else @@ -554,4 +554,4 @@ trait ClassLikeSupport: if parameters(0).symbol.flags.is(Flags.Given) then "using " else if parameters(0).symbol.flags.is(Flags.Implicit) then "implicit " else "" - else "" \ No newline at end of file + else "" diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/SyntheticSupport.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/SyntheticSupport.scala index f04ef6689767..8b98e40fd6b0 100644 --- a/scaladoc/src/dotty/tools/scaladoc/tasty/SyntheticSupport.scala +++ b/scaladoc/src/dotty/tools/scaladoc/tasty/SyntheticSupport.scala @@ -34,25 +34,16 @@ object SyntheticsSupport: c.constructor.leadingTypeParams.nonEmpty && end <= typesEnd + 1 } - /* We need there to filter out symbols with certain flagsets, because these symbols come from compiler and TASTY can't handle them well. - They are valdefs that describe case companion objects and cases from enum. - TASTY crashed when calling _.tree on them. - */ - def getSupertypes(using Quotes)(c: reflect.ClassDef) = c.symbol.typeRef.baseClasses.map(b => b -> c.symbol.typeRef.baseType(b)).tail def typeForClass(using Quotes)(c: reflect.ClassDef): reflect.TypeRepr = c.symbol.typeRef.appliedTo(c.symbol.typeMembers.filter(_.isTypeParam).map(_.typeRef)) - def memberInfo(using Quotes)(c: reflect.ClassDef, symbol: reflect.Symbol): reflect.TypeRepr = - import reflect._ - import dotty.tools.dotc - 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] - + /* We need there to filter out symbols with certain flagsets, because these symbols come from compiler and TASTY can't handle them well. + They are valdefs that describe case companion objects and cases from enum. + TASTY crashed when calling _.tree on them. + */ private def hackGetmembers(using Quotes)(rsym: reflect.Symbol): List[reflect.Symbol] = { import reflect._ import dotty.tools.dotc